// AlsaCore.cpp - Wrapper for ALSA library to record and play wave files

#include <iostream>
#include <stdio.h>
#include <malloc.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <time.h>
#include <locale.h>
#include <assert.h>
#include <termios.h>
#include <signal.h>
#include <output.h>
#include <sys/poll.h>
#include <sys/uio.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <asm/byteorder.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <libintl.h>
#include <endian.h>
#include <byteswap.h>
#include <math.h>
#include <pthread.h>
#include "gettext.h"
#include "formats.h"
#include "version.h"
#include "RingBuffer.h"
#include "AlsaCore.h"

fmt_capture_t AlsaCore::fmt_rec_table[] = {
        { NULL,                  NULL,               (char *)N_("raw data"),     LLONG_MAX },
        { AlsaCore::_begin_voc,  AlsaCore::_end_voc, (char *)N_("VOC"),          16000000LL },
        { AlsaCore::_begin_wave, AlsaCore::_end_wave,(char *)N_("WAVE"),         2147483648LL },
        { AlsaCore::_begin_au,   AlsaCore::_end_au,  (char *)N_("Sparc Audio"),  LLONG_MAX }
};

AlsaCore::AlsaCore()
{
	command 				= (char *)"aplay";
	handle 					= NULL;
	fdcount 				= 0;
	pidfile_written 		= 0;
	pidfile_name 			= NULL;
	timelimit 				= 4;
	quiet_mode 				= 0;
	file_type 				= FORMAT_DEFAULT;
	open_mode 				= 0;
	stream 					= SND_PCM_STREAM_PLAYBACK;
	mmap_flag 				= 0;
	interleaved 			= 1;
	nonblock 				= 0;
	in_aborting 			= 0;
	audiobuf 				= NULL;
	chunk_size 				= 0;
	period_time 			= 0;
	buffer_time 			= 0;
	period_frames 			= 0;
	buffer_frames 			= 0;
	avail_min 				= -1;
	start_delay 			= 0;
	stop_delay 				= 0;
	monotonic 				= 0;
	interactive 			= 0;
	can_pause 				= 0;
	fatal_errors 			= 0;
	verbose 				= 0;
	vumeter 				= VUMETER_NONE;
	buffer_pos 				= 0;
	bits_per_sample 		= 0;
	bits_per_frame 			= 0;
	chunk_bytes 			= 0;
	test_position 			= 0;
	test_coef 				= 8;
	test_nowait 			= 0;
	max_file_size 			= 0;
	max_file_time 			= 0;
	use_strftime 			= 0;
	recycle_capture_file 	= 0;
	term_c_lflag 			= -1;
	dump_hw_params 			= 0;
	fd 						= -1;
	pbrec_count 			= LLONG_MAX;
	fdcount 				= 0;
	vocmajor 				= 0;
	vocminor 				= 0;
	pidfile_name 			= NULL;
	capture_stop 			= 0;
	resample 				= 1;
	period_size				= 0;
	block					= 0;
	buffer_size				= 0;
	output 					= NULL;
	latency_min 			= 32;
	latency_max				= 2048;
	loop_limit				= 0;
	loop_sec 				= 5;
	use_poll 				= 1;
	effect					= 0;
	lfo						= 0;
	dlfo					= 0;
	fs						= 0;
	fc						= 0;
	BW						= 0;
	C						= 0;
	D						= 0;
	a0						= 0;
	a1						= 0;
	a2						= 0;
	b1						= 0;
	b2						= 0;
	*x						= NULL;
	*y						= NULL;
	loghandle				= NULL;

#ifdef CONFIG_SUPPORT_CHMAP
	channel_map 			= NULL; // chmap to override
	hw_map 					= NULL; // chmap to follow
#endif

	readi_func  = NULL;
	writei_func = NULL;
	readn_func  = NULL;
	writen_func = NULL;
}

// Wave file handling destructor
AlsaCore::~AlsaCore()
{
}

// Configurable parameter list
void AlsaCore::usage(char *command)
{
	printf(
			_(
					"Usage: %s [OPTION]... [FILE]...\n"
					"\n"
					"-h, --help              help\n"
					"    --version           print current version\n"
					"-l, --list-devices      list all soundcards and digital audio devices\n"
					"-L, --list-pcms         list device names\n"
					"-D, --device=NAME       select PCM by name\n"
					"-q, --quiet             quiet mode\n"
					"-t, --file-type TYPE    file type (voc, wav, raw or au)\n"
					"-c, --channels=#        channels\n"
					"-f, --format=FORMAT     sample format (case insensitive)\n"
					"-r, --rate=#            sample rate\n"
					"-d, --duration=#        interrupt after # seconds\n"
					"-M, --mmap              mmap stream\n"
					"-N, --nonblock          nonblocking mode\n"
					"-F, --period-time=#     distance between interrupts is # microseconds\n"
					"-B, --buffer-time=#     buffer duration is # microseconds\n"
					"    --period-size=#     distance between interrupts is # frames\n"
					"    --buffer-size=#     buffer duration is # frames\n"
					"-A, --avail-min=#       min available space for wakeup is # microseconds\n"
					"-R, --start-delay=#     delay for automatic PCM start is # microseconds \n"
					"                        (relative to buffer size if <= 0)\n"
					"-T, --stop-delay=#      delay for automatic PCM stop is # microseconds from xrun\n"
					"-v, --verbose           show PCM structure and setup (accumulative)\n"
					"-V, --vumeter=TYPE      enable VU meter (TYPE: mono or stereo)\n"
					"-I, --separate-channels one file for each channel\n"
					"-i, --interactive       allow interactive operation from stdin\n"
					"-m, --chmap=ch1,ch2,..  Give the channel map to override or follow\n"
					"    --disable-resample  disable automatic rate resample\n"
					"    --disable-channels  disable automatic channel conversions\n"
					"    --disable-format    disable automatic format conversions\n"
					"    --disable-softvol   disable software volume control (softvol)\n"
					"    --test-position     test ring buffer position\n"
					"    --test-coef=#       test coefficient for ring buffer position (default 8)\n"
					"                        expression for validation is: coef * (buffer_size / 2)\n"
					"    --test-nowait       do not wait for ring buffer - eats whole CPU\n"
					"    --max-file-time=#   start another output file when the old file has recorded\n"
					"                        for this many seconds\n"
					"    --process-id-file   write the process ID here\n"
					"    --use-strftime      apply the strftime facility to the output file name\n"
					"    --dump-hw-params    dump hw_params of the device\n"
					"    --fatal-errors      treat all errors as fatal\n"
			), command);

	printf(_("Recognized sample formats are:"));
	int k;
	for (k = 0; k <= (int)SND_PCM_FORMAT_LAST; ++k)
	{
		const char *s = snd_pcm_format_name((snd_pcm_format_t)k);
		if (s) {
			printf(" %s", s);
		}
	}
	printf(_("\nSome of these may not be available on selected hardware\n"));
	printf(_("The available format shortcuts are:\n"));
	printf(_("-f cd  (16 bit little endian, 44100, stereo)\n"));
	printf(_("-f cdr (16 bit big endian,    44100, stereo)\n"));
	printf(_("-f dat (16 bit little endian, 48000, stereo)\n"));
}

// Display device list
void AlsaCore::device_list(void)
{
	snd_ctl_t *handle;
	int card, err, dev, idx;
	snd_ctl_card_info_t *info;
	snd_pcm_info_t *pcminfo;
	snd_ctl_card_info_alloca(&info);
	snd_pcm_info_alloca(&pcminfo);

	card = -1;
	if (snd_card_next(&card) < 0 || card < 0) {
		error(_("no soundcards found..."));
		return;
	}
	printf(_("\n**** List of %s Hardware Devices ****\n"),
			snd_pcm_stream_name(stream));

	while (card >= 0) {
		char name[32];
		sprintf(name, "hw:%d", card);
		if ((err = snd_ctl_open(&handle, name, 0)) < 0) {
			error("control open (%i): %s", card, snd_strerror(err));
			goto next_card;
		}

		if ((err = snd_ctl_card_info(handle, info)) < 0) {
			error("control hardware info (%i): %s", card, snd_strerror(err));
			snd_ctl_close(handle);
			goto next_card;
		}

		dev = -1;
		while (true) {
			unsigned int count;

			if (snd_ctl_pcm_next_device(handle, &dev) < 0) {
				error("snd_ctl_pcm_next_device");
			}

			if (dev < 0) {
				break;
			}

			snd_pcm_info_set_device(pcminfo, dev);
			snd_pcm_info_set_subdevice(pcminfo, 0);
			snd_pcm_info_set_stream(pcminfo, stream);
			if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
				if (err != -ENOENT) {
					error("control digital audio info (%i): %s", card, snd_strerror(err));
				}
				continue;
			}

			printf(_("card %i: %s [%s], device %i: %s [%s]\n"),
					card, snd_ctl_card_info_get_id(info), snd_ctl_card_info_get_name(info),
					dev,
					snd_pcm_info_get_id(pcminfo),
					snd_pcm_info_get_name(pcminfo));

			count = snd_pcm_info_get_subdevices_count(pcminfo);
			printf( _("  Subdevices: %i/%i\n"),
					snd_pcm_info_get_subdevices_avail(pcminfo), count);

			for (idx = 0; idx < (int)count; idx++) {
				snd_pcm_info_set_subdevice(pcminfo, idx);
				if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
					error("control digital audio playback info (%i): %s", card, snd_strerror(err));
				} else {
					printf(_("  Subdevice #%i: %s\n"),
							idx, snd_pcm_info_get_subdevice_name(pcminfo));
				}
			}
		}
		snd_ctl_close(handle);

		next_card:
		if (snd_card_next(&card) < 0) {
			error("snd_card_next");
			break;
		}
	}
}

// Display PCM list
void AlsaCore::pcm_list(void)
{
	void **hints, **n;
	char *name, *descr, *descr1, *io;
	const char *filter;

	if (snd_device_name_hint(-1, "pcm", &hints) < 0) {
		return;
	}
	printf("\n**** List of PCM Devices ****\n");

	n = hints;
	filter = stream == SND_PCM_STREAM_CAPTURE ? "Input" : "Output";
	while (*n != NULL) {
		name  = snd_device_name_get_hint(*n, "NAME");
		descr = snd_device_name_get_hint(*n, "DESC");
		io    = snd_device_name_get_hint(*n, "IOID");
		if (io != NULL && strcmp(io, filter) != 0) {
			goto __end;
		}
		printf("%s\n", name);
		if ((descr1 = descr) != NULL) {
			printf("    ");
			while (*descr1) {
				if (*descr1 == '\n') {
					printf("\n    ");
				} else {
					putchar(*descr1);
				}
				descr1++;
			}
			putchar('\n');
		}

		__end:
		if (name != NULL) {
			free(name);
		}
		if (descr != NULL) {
			free(descr);
		}
		if (io != NULL) {
			free(io);
		}
		n++;
	}

	snd_device_name_free_hint(hints);
}

// Display version for standalone
void AlsaCore::version(void)
{
	printf("%s: version \" SND_UTIL_VERSION_STR \" by Jaroslav Kysela <perex@perex.cz> modified to C++ for Bosch by Jim Lundberg\n", command);
}

// Subroutine to clean up before exit.
void AlsaCore::prg_exit(int code)
{
	AlsaCore::done_stdin();

	if (handle) {
		snd_pcm_close(handle);
	}

	if (pidfile_written) {
		remove(pidfile_name);
	}

	//exit(code);
}

//todo: later
#if 0
// Callback handler
void AlsaCore::signal_handler(int sig)
{
	if (in_aborting) {
		return;
	}

	in_aborting = 1;

	if (verbose == 2) {
		putchar('\n');
	}

	if (!quiet_mode) {
		fprintf(stderr, _("Aborted by signal %s...\n"), strsignal(sig));
	}

	if (handle) {
		snd_pcm_abort(handle);
	}

	if (sig == SIGABRT) {
		// Do not call snd_pcm_close() and abort immediately
		handle = NULL;
		prg_exit(EXIT_FAILURE);
	}

	signal(sig, signal_handler);
}

// call on SIGUSR1 signal
void AlsaCore::signal_handler_recycle(int sig)
{
	// Flag the capture loop to start a new output file
	recycle_capture_file = 1;
}

#endif

// Safe read (for pipes)
ssize_t AlsaCore::safe_read(int fd, void *buf, size_t count)
{
	ssize_t result = 0, res;

	while (count > 0 && !in_aborting) {
		if ((res = read(fd, buf, count)) == 0) {
			break;
		}

		if (res < 0) {
			return (result > 0 ? result : res);
		}

		count  -= res;
		result += res;
		buf = (char *)buf + res;
	}

	return (result);
}

// Test, if it is a .VOC file and return >=0 if ok (this is the length of rest)
//                                       < 0 if not
int AlsaCore::test_vocfile(void *buffer)
{
	VocHeader *vp = (VocHeader *)buffer;

	if (!memcmp(vp->magic, VOC_MAGIC_STRING, 20)) {
		vocminor = LE_SHORT(vp->version) & 0xFF;
		vocmajor = LE_SHORT(vp->version) / 256;
		if (LE_SHORT(vp->version) != (0x1233 - LE_SHORT(vp->coded_ver))) {
			return (-2);	// coded version mismatch
		}
		return (LE_SHORT(vp->headerlen) - sizeof(VocHeader));	// 0 mostly
	}

	return (-1); // magic string fail
}

// Read wave file helper for test_wavefile
size_t AlsaCore::test_wavefile_read(int fd, unsigned char *buffer, size_t *size, size_t reqsize, int line)
{
	if (*size >= reqsize) {
		return *size;
	}

	if ((size_t)safe_read(fd, buffer + *size, reqsize - *size) != reqsize - *size) {
		error(_("read error (called from line %i)"), line);
		prg_exit(EXIT_FAILURE);
	}

	return (*size = reqsize);
}

// test, if it's a .WAV file, > 0 if ok (and set the speed, stereo etc.)
//                           == 0 if not
// Value returned is bytes to be discarded.
ssize_t AlsaCore::test_wavefile(int fd, unsigned char *_buffer, size_t size)
{
	WaveHeader *h = (WaveHeader *)_buffer;
	unsigned char *buffer = NULL;
	size_t blimit = 0;
	WaveFmtBody *f;
	WaveChunkHeader *c;
	u_int type, len;
	unsigned short format, channels;
	int big_endian, native_format;

	if (size < sizeof(WaveHeader)) {
		return (-1);
	}

	if (h->magic == WAV_RIFF) {
		big_endian = 0;
	} else if (h->magic == WAV_RIFX) {
		big_endian = 1;
	} else {
		return (-1);
	}

	if (h->type != WAV_WAVE) {
		return (-1);
	}

	if (size > sizeof(WaveHeader)) {
		check_wavefile_space(buffer, size - sizeof(WaveHeader), blimit);
		memcpy(buffer, _buffer + sizeof(WaveHeader), size - sizeof(WaveHeader));
	}
	size -= sizeof(WaveHeader);
	while (true) {
		check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit);
		test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__);
		c = (WaveChunkHeader*)buffer;
		type = c->type;
		len = TO_CPU_INT(c->length, big_endian);
		len += len % 2;
		if (size > sizeof(WaveChunkHeader)) {
			memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader));
		}
		size -= sizeof(WaveChunkHeader);
		if (type == WAV_FMT) {
			break;
		}
		check_wavefile_space(buffer, len, blimit);
		test_wavefile_read(fd, buffer, &size, len, __LINE__);
		if (size > len) {
			memmove(buffer, buffer + len, size - len);
		}
		size -= len;
	}

	if (len < sizeof(WaveFmtBody)) {
		error(_("unknown length of 'fmt ' chunk (read %u, should be %u at least)"),
				len, (u_int)sizeof(WaveFmtBody));
		prg_exit(EXIT_FAILURE);
	}

	check_wavefile_space(buffer, len, blimit);
	test_wavefile_read(fd, buffer, &size, len, __LINE__);

	f = (WaveFmtBody*) buffer;
	format = TO_CPU_SHORT(f->format, big_endian);
	if (format == WAV_FMT_EXTENSIBLE) {
		WaveFmtExtensibleBody *fe = (WaveFmtExtensibleBody*)buffer;
		if (len < sizeof(WaveFmtExtensibleBody)) {
			error(_("unknown length of extensible 'fmt ' chunk (read %u, should be %u at least)"),
					len, (u_int)sizeof(WaveFmtExtensibleBody));
			prg_exit(EXIT_FAILURE);
		}

		if (memcmp(fe->guid_tag, WAV_GUID_TAG, 14) != 0) {
			error(_("wrong format tag in extensible 'fmt ' chunk"));
			prg_exit(EXIT_FAILURE);
		}

		format = TO_CPU_SHORT(fe->guid_format, big_endian);
	}

	if (format != WAV_FMT_PCM && format != WAV_FMT_IEEE_FLOAT) {
		error(_("can't play WAVE-file format 0x%04x which is not PCM or FLOAT encoded"), format);
		prg_exit(EXIT_FAILURE);
	}

	channels = TO_CPU_SHORT(f->channels, big_endian);
	if (channels < 1) {
		error(_("can't play WAVE-files with %d tracks"), channels);
		prg_exit(EXIT_FAILURE);
	}

	hwparams.channels = channels;
	switch (TO_CPU_SHORT(f->bit_p_spl, big_endian)) {
	case 8:
		if (hwparams.format != DEFAULT_FORMAT &&
				hwparams.format != SND_PCM_FORMAT_U8) {
			fprintf(stderr, _("Warning: format is changed to U8\n"));
		}
		hwparams.format = SND_PCM_FORMAT_U8;
		break;

	case 16:
		if (big_endian) {
			native_format = SND_PCM_FORMAT_S16_BE;
		} else {
			native_format = SND_PCM_FORMAT_S16_LE;
		}
		if (hwparams.format != DEFAULT_FORMAT &&
				hwparams.format != native_format) {
			fprintf(stderr, _("Warning: format is changed to %s\n"),
					snd_pcm_format_name((snd_pcm_format_t)native_format));
		}
		hwparams.format = (snd_pcm_format_t)native_format;
		break;

	case 24:
		switch (TO_CPU_SHORT(f->byte_p_spl, big_endian) / hwparams.channels) {
		case 3:
			if (big_endian) {
				native_format = SND_PCM_FORMAT_S24_3BE;
			} else {
				native_format = SND_PCM_FORMAT_S24_3LE;
			}
			if (hwparams.format != DEFAULT_FORMAT &&
					hwparams.format != native_format) {
				fprintf(stderr, _("Warning: format is changed to %s\n"),
						snd_pcm_format_name((snd_pcm_format_t)native_format));
			}
			hwparams.format = (snd_pcm_format_t)native_format;
			break;

		case 4:
			if (big_endian) {
				native_format = SND_PCM_FORMAT_S24_BE;
			} else {
				native_format = SND_PCM_FORMAT_S24_LE;
			}

			if (hwparams.format != DEFAULT_FORMAT &&
					hwparams.format != native_format) {
				fprintf(stderr, _("Warning: format is changed to %s\n"),
						snd_pcm_format_name((snd_pcm_format_t)native_format));
			}
			hwparams.format = (snd_pcm_format_t)native_format;
			break;

		default:
			error(_(" can't play WAVE-files with sample %d bits in %d bytes wide (%d channels)"),
					TO_CPU_SHORT(f->bit_p_spl, big_endian),
					TO_CPU_SHORT(f->byte_p_spl, big_endian),
					hwparams.channels);
			prg_exit(EXIT_FAILURE);
		}
		break;

		case 32:
			if (format == WAV_FMT_PCM) {
				if (big_endian) {
					native_format = SND_PCM_FORMAT_S32_BE;
				} else {
					native_format = SND_PCM_FORMAT_S32_LE;
				}

				hwparams.format = (snd_pcm_format_t)native_format;
			} else if (format == WAV_FMT_IEEE_FLOAT) {
				if (big_endian) {
					native_format = SND_PCM_FORMAT_FLOAT_BE;
				} else {
					native_format = SND_PCM_FORMAT_FLOAT_LE;
				}
				hwparams.format = (snd_pcm_format_t)native_format;
			}
			break;

		default:
			error((char*)" can't play WAVE-files with sample %d bits wide",
					TO_CPU_SHORT(f->bit_p_spl, big_endian));
			prg_exit(EXIT_FAILURE);
	}
	hwparams.rate = TO_CPU_INT(f->sample_fq, big_endian);

	if (size > len) {
		memmove(buffer, buffer + len, size - len);
	}
	size -= len;

	while (true) {
		u_int type, len;

		check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit);
		test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__);
		c = (WaveChunkHeader*)buffer;
		type = c->type;
		len = TO_CPU_INT(c->length, big_endian);
		if (size > sizeof(WaveChunkHeader)) {
			memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader));
		}
		size -= sizeof(WaveChunkHeader);
		if (type == WAV_DATA) {
			if (len < pbrec_count && len < 0x7ffffffe) {
				pbrec_count = len;
			}
			if (size > 0) {
				memcpy(_buffer, buffer, size);
			}
			free(buffer);
			return (size);
		}

		len += len % 2;
		check_wavefile_space(buffer, len, blimit);
		test_wavefile_read(fd, buffer, &size, len, __LINE__);

		if (size > len) {
			memmove(buffer, buffer + len, size - len);
		}
		size -= len;
	}

	// Shouldn't be reached
	return (-1);
}

// test au
int AlsaCore::test_au(int fd, void *buffer)
{
	AuHeader *ap = (AuHeader *)buffer;

	if (ap->magic != AU_MAGIC) {
		return (-1);
	}

	if (BE_INT(ap->hdr_size) > 128 || BE_INT(ap->hdr_size) < 24) {
		return (-1);
	}

	pbrec_count = BE_INT(ap->data_size);
	switch (BE_INT(ap->encoding)) {
	case AU_FMT_ULAW:
		if (hwparams.format != DEFAULT_FORMAT &&
				hwparams.format != SND_PCM_FORMAT_MU_LAW) {
			fprintf(stderr, _("Warning: format is changed to MU_LAW\n"));
		}
		hwparams.format = SND_PCM_FORMAT_MU_LAW;
		break;

	case AU_FMT_LIN8:
		if (hwparams.format != DEFAULT_FORMAT &&
				hwparams.format != SND_PCM_FORMAT_U8) {
			fprintf(stderr, _("Warning: format is changed to U8\n"));
		}
		hwparams.format = SND_PCM_FORMAT_U8;
		break;

	case AU_FMT_LIN16:
		if (hwparams.format != DEFAULT_FORMAT &&
				hwparams.format != SND_PCM_FORMAT_S16_BE) {
			fprintf(stderr, _("Warning: format is changed to S16_BE\n"));
		}
		hwparams.format = SND_PCM_FORMAT_S16_BE;
		break;

	default:
		return (-1);
	}

	hwparams.rate = BE_INT(ap->sample_rate);
	if (hwparams.rate < 2000 || hwparams.rate > 256000) {
		return (-1);
	}

	hwparams.channels = BE_INT(ap->channels);
	if (hwparams.channels < 1 || hwparams.channels > 256) {
		return (-1);
	}

	if ((size_t)safe_read(fd, (char *)buffer + sizeof(AuHeader),
			BE_INT(ap->hdr_size) - sizeof(AuHeader)) != BE_INT(ap->hdr_size) - sizeof(AuHeader)) {
		error(_("read error"));
		prg_exit(EXIT_FAILURE);
	}

	return (0);
}

// Display list of sample formats
void AlsaCore::show_available_sample_formats(snd_pcm_hw_params_t* params)
{
	int format;

	fprintf(stderr, "Available formats:\n");
	for (format = 0; format <= (int)SND_PCM_FORMAT_LAST; format++) {
		if (snd_pcm_hw_params_test_format(handle, params, (snd_pcm_format_t)format) == 0) {
			fprintf(stderr, "- %s\n", snd_pcm_format_name((snd_pcm_format_t)format));
		}
	}
}

#ifdef CONFIG_SUPPORT_CHMAP
// Setup character map
int AlsaCore::setup_chmap(void)
{
	snd_pcm_chmap_t *chmap = channel_map;
	char mapped[hwparams.channels];
	snd_pcm_chmap_t *hw_chmap;
	unsigned int ch, i;
	int err;

	if (!chmap) {
		return (0);
	}

	if (chmap->channels != hwparams.channels) {
		error(_("Channel numbers don't match between hw_params and channel map"));
		return (-1);
	}

	err = snd_pcm_set_chmap(handle, chmap);
	if (!err) {
		return (0);
	}

	hw_chmap = snd_pcm_get_chmap(handle);
	if (!hw_chmap) {
		fprintf(stderr, _("Warning: unable to get channel map\n"));
		return (0);
	}

	if (hw_chmap->channels == chmap->channels &&
			!memcmp(hw_chmap, chmap, 4 * (chmap->channels + 1))) {
		// Maps are identical, so no need to convert
		free(hw_chmap);
		return (0);
	}

	hw_map = (unsigned int *)calloc(hwparams.channels, sizeof(int));
	if (!hw_map) {
		error(_("not enough memory"));
		return (-1);
	}

	memset(mapped, 0, sizeof(mapped));
	for (ch = 0; ch < hw_chmap->channels; ch++) {
		if (chmap->pos[ch] == hw_chmap->pos[ch]) {
			mapped[ch] = 1;
			hw_map[ch] = ch;
			continue;
		}

		for (i = 0; i < hw_chmap->channels; i++) {
			if (!mapped[i] && chmap->pos[ch] == hw_chmap->pos[i]) {
				mapped[i] = 1;
				hw_map[ch] = i;
				break;
			}
		}

		if (i >= hw_chmap->channels) {
			char buf[256];
			error(_("Channel %d doesn't match with hw_parmas"), ch);
			snd_pcm_chmap_print(hw_chmap, sizeof(buf), buf);
			fprintf(stderr, "hardware chmap = %s\n", buf);
			return (-1);
		}
	}

	free(hw_chmap);
	return (0);
}
#else
#define setup_chmap()	0
#endif

// Configure record parameters
void AlsaCore::set_record_params(void)
{
	snd_pcm_hw_params_t *params;
	snd_pcm_sw_params_t *swparams;
	snd_pcm_uframes_t buffer_size;
	int err;
	size_t n;
	unsigned int rate;
	snd_pcm_uframes_t start_threshold, stop_threshold;

	snd_pcm_hw_params_alloca(&params);
	snd_pcm_sw_params_alloca(&swparams);

	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0) {
		error(_("Broken configuration for this PCM: no configurations available"));
		exit(EXIT_FAILURE);
	} else if (interleaved) {
		err = snd_pcm_hw_params_set_access(handle, params,
				SND_PCM_ACCESS_RW_INTERLEAVED);
	} else {
		err = snd_pcm_hw_params_set_access(handle, params,
				SND_PCM_ACCESS_RW_NONINTERLEAVED);
	}

	if (err < 0) {
		error(_("Access type not available"));
		exit(EXIT_FAILURE);
	}

	err = snd_pcm_hw_params_set_format(handle, params, hwparams.format);
	if (err < 0) {
		error(_("Sample format non available"));
		exit(EXIT_FAILURE);
	}

	err = snd_pcm_hw_params_set_channels(handle, params, hwparams.channels);
	if (err < 0) {
		error(_("Channels count non available"));
		exit(EXIT_FAILURE);
	}

#if 0
	err = snd_pcm_hw_params_set_periods_min(handle, params, 2);
	assert(err >= 0);
#endif

	rate = hwparams.rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &hwparams.rate, 0);
	assert(err >= 0);

	if ((float)rate * 1.05 < hwparams.rate || (float)rate * 0.95 > hwparams.rate) {
		if (!quiet_mode) {
			char plugex[64];
			const char *pcmname = snd_pcm_name(handle);
			fprintf(stderr, _("Warning: rate is not accurate (requested = %iHz, got = %iHz)\n"), rate, hwparams.rate);

			if (! pcmname || strchr(snd_pcm_name(handle), ':')) {
				*plugex = 0;
			} else {
				snprintf(plugex, sizeof(plugex), "(-Dplug:%s)",
						snd_pcm_name(handle));
			}

			fprintf(stderr, _(" please, try the plug plugin %s\n"),
					plugex);
		}
	}

	rate = hwparams.rate;
	if (buffer_time == 0 && buffer_frames == 0) {
		err = snd_pcm_hw_params_get_buffer_time_max(params,
				&buffer_time, 0);
		assert(err >= 0);
		if (buffer_time > 500000) {
			buffer_time = 500000;
		}
	}

	if (period_time == 0 && period_frames == 0) {
		if (buffer_time > 0) {
			period_time = buffer_time / 4;
		} else {
			period_frames = buffer_frames / 4;
		}
	}

	if (period_time > 0) {
		err = snd_pcm_hw_params_set_period_time_near(handle, params,
				&period_time, 0);
	} else {
		err = snd_pcm_hw_params_set_period_size_near(handle, params,
				&period_frames, 0);
	}
	assert(err >= 0);

	if (buffer_time > 0) {
		err = snd_pcm_hw_params_set_buffer_time_near(handle, params,
				&buffer_time, 0);
	} else {
		err = snd_pcm_hw_params_set_buffer_size_near(handle, params,
				&buffer_frames);
	}
	assert(err >= 0);

	err = snd_pcm_hw_params(handle, params);
	if (err < 0) {
		error(_("Unable to install hw params:"));
		exit(EXIT_FAILURE);
	}

	snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);
	snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
	if (chunk_size == buffer_size) {
		error(_("Can't use period equal to buffer size (%lu == %lu)"),
				chunk_size, buffer_size);
		exit(EXIT_FAILURE);
	}

	snd_pcm_sw_params_current(handle, swparams);
	if (avail_min < 0) {
		n = chunk_size;
	} else {
		n = (double) rate * avail_min / 1000000;
	}
	err = snd_pcm_sw_params_set_avail_min(handle, swparams, n);

	// Round up to closest transfer boundary
	n = buffer_size;
	if (start_delay <= 0) {
		start_threshold = n + (double) rate * start_delay / 1000000;
	} else {
		start_threshold = (double) rate * start_delay / 1000000;
	}

	if (start_threshold < 1) {
		start_threshold = 1;
	}

	if (start_threshold > n) {
		start_threshold = n;
	}

	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);
	assert(err >= 0);
	if (stop_delay <= 0) {
		stop_threshold = buffer_size + (double) rate * stop_delay / 1000000;
	} else {
		stop_threshold = (double) rate * stop_delay / 1000000;
	}

	err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold);
	assert(err >= 0);

	if (snd_pcm_sw_params(handle, swparams) < 0) {
		error(_("unable to install sw params:"));
		exit(EXIT_FAILURE);
	}

	bits_per_sample = snd_pcm_format_physical_width(hwparams.format);
	bits_per_frame = bits_per_sample * hwparams.channels;
	chunk_bytes = chunk_size * bits_per_frame / 8;
	audiobuf = (unsigned char *)realloc(audiobuf, chunk_bytes);
	if (audiobuf == NULL) {
		error(_("not enough memory"));
		exit(EXIT_FAILURE);
	}

	// 	fprintf(stderr, "real chunk_size = %i, frags = %i, total = %i\n", chunk_size, setup.buf.block.frags, setup.buf.block.frags * chunk_size);

	// stereo VU-meter isn't always available...
	if (vumeter == VUMETER_STEREO) {
		if (hwparams.channels != 2 || !interleaved || verbose > 2) {
			vumeter = VUMETER_MONO;
		}
	}

	buffer_frames = buffer_size;	// For position test
}

// Initialize Standard IN
void AlsaCore::init_stdin(void)
{
	struct termios term;
	long flags;

	if (!interactive) {
		return;
	}

	if (!isatty(fileno(stdin))) {
		interactive = 0;
		return;
	}

	tcgetattr(fileno(stdin), &term);
	term_c_lflag = term.c_lflag;
	if (fd == fileno(stdin)) {
		return;
	}

	flags = fcntl(fileno(stdin), F_GETFL);
	if (flags < 0 || fcntl(fileno(stdin), F_SETFL, flags|O_NONBLOCK) < 0) {
		fprintf(stderr, _("stdin O_NONBLOCK flag setup failed\n"));
	}
	term.c_lflag &= ~ICANON;
	tcsetattr(fileno(stdin), TCSANOW, &term);
}

// Check Standard IN
void AlsaCore::check_stdin(void)
{
	unsigned char b;

	if (!interactive) {
		return;
	}

	if (fd != fileno(stdin)) {
		while (read(fileno(stdin), &b, 1) == 1) {
			if (b == ' ' || b == '\r') {
				while (read(fileno(stdin), &b, 1) == 1);
				fprintf(stderr, _("\r=== PAUSE ===                                                            "));
				fflush(stderr);
				do_pause();
				fprintf(stderr, "                                                                          \r");
				fflush(stderr);
			}
		}
	}
}

// Close Standard IN
void AlsaCore::done_stdin(void)
{
	struct termios term;

	if (!interactive) {
		return;
	}

	if (fd == fileno(stdin) || term_c_lflag == -1) {
		return;
	}

	tcgetattr(fileno(stdin), &term);
	term.c_lflag = term_c_lflag;
	tcsetattr(fileno(stdin), TCSANOW, &term);
}

// Pause
void AlsaCore::do_pause(void)
{
	int err;
	unsigned char b;

	if (!can_pause) {
		fprintf(stderr, _("\rPAUSE command ignored (no hw support)\n"));
		return;
	}

	err = snd_pcm_pause(handle, 1);
	if (err < 0) {
		error(_("pause push error: %s"), snd_strerror(err));
		return;
	}

	while (true) {
		while (read(fileno(stdin), &b, 1) != 1);
		if (b == ' ' || b == '\r') {
			while (read(fileno(stdin), &b, 1) == 1);
			err = snd_pcm_pause(handle, 0);
			if (err < 0) {
				error(_("pause release error: %s"), snd_strerror(err));
			}
			return;
		}
	}
}

// I/O play error handler
void AlsaCore::xrun_play(void)
{
	snd_pcm_status_t *status;
	int res;

	snd_pcm_status_alloca(&status);
	if ((res = snd_pcm_status(handle, status)) < 0) {
		error(_("status error: %s"), snd_strerror(res));
		prg_exit(EXIT_FAILURE);
	}

	if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
		if (fatal_errors) {
			error(_("fatal %s: %s"),
					stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
							snd_strerror(res));
			prg_exit(EXIT_FAILURE);
		}

		if (monotonic) {
#ifdef HAVE_CLOCK_GETTIME
			struct timespec now, diff, tstamp;
			clock_gettime(CLOCK_MONOTONIC, &now);
			snd_pcm_status_get_trigger_htstamp(status, &tstamp);
			timermsub(&now, &tstamp, &diff);
			fprintf(stderr, _("%s!!! (at least %.3f ms long)\n"),
					stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
							diff.tv_sec * 1000 + diff.tv_nsec / 1000000.0);
#else
			fprintf(stderr, "%s !!!\n", _("underrun"));
#endif
		} else {
			struct timeval now, diff, tstamp;
			gettimeofday(&now, 0);
			snd_pcm_status_get_trigger_tstamp(status, &tstamp);
			timersub(&now, &tstamp, &diff);
			fprintf(stderr, _("%s!!! (at least %.3f ms long)\n"),
					stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
							diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
		}

		if (verbose) {
			fprintf(stderr, _("Status:\n"));
			snd_pcm_status_dump(status, loghandle);
		}

		if ((res = snd_pcm_prepare(handle)) < 0) {
			error(_("xrun: prepare error: %s"), snd_strerror(res));
			prg_exit(EXIT_FAILURE);
		}

		return;	// OK, data should be accepted again
	}

	if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) {
		if (verbose) {
			fprintf(stderr, _("Status(DRAINING):\n"));
			snd_pcm_status_dump(status, loghandle);
		}

		if (stream == SND_PCM_STREAM_CAPTURE) {
			fprintf(stderr, _("capture stream format change? attempting recover...\n"));
			if ((res = snd_pcm_prepare(handle)) < 0) {
				error(_("xrun(DRAINING): prepare error: %s"), snd_strerror(res));
				prg_exit(EXIT_FAILURE);
			}
			return;
		}
	}

	if (verbose) {
		fprintf(stderr, _("Status(R/W):\n"));
		snd_pcm_status_dump(status, loghandle);
	}

	error(_("read/write error, state = %s"), snd_pcm_state_name(snd_pcm_status_get_state(status)));
	prg_exit(EXIT_FAILURE);
}

// Display mono vu meter text line
void AlsaCore::print_vu_meter_mono(int perc, int maxperc)
{
	const int bar_length = 50;
	char line[80];
	int val;

	for (val = 0; val <= perc * bar_length / 100 && val < bar_length; val++) {
		line[val] = '#';
	}

	for (; val <= maxperc * bar_length / 100 && val < bar_length; val++) {
		line[val] = ' ';
	}

	line[val] = '+';
	for (++val; val <= bar_length; val++) {
		line[val] = ' ';
	}

	if (maxperc > 99) {
		sprintf(line + val, "| MAX");
	} else {
		sprintf(line + val, "| %02i%%", maxperc);
	}

	fputs(line, stderr);

	if (perc > 100) {
		fprintf(stderr, _(" !clip  "));
	}
}

// Display stereo vu meter text line
void AlsaCore::print_vu_meter_stereo(int *perc, int *maxperc)
{
	const int bar_length = 35;
	char line[80];
	int c;

	memset(line, ' ', sizeof(line) - 1);
	line[bar_length + 3] = '|';

	for (c = 0; c < 2; c++) {
		int p = perc[c] * bar_length / 100;
		char tmp[4];

		if (p > bar_length) {
			p = bar_length;
		}

		if (c) {
			memset(line + bar_length + 6 + 1, '#', p);
		} else {
			memset(line + bar_length - p - 1, '#', p);
		}

		p = maxperc[c] * bar_length / 100;
		if (p > bar_length) {
			p = bar_length;
		}

		if (c) {
			line[bar_length + 6 + 1 + p] = '+';
		} else {
			line[bar_length - p - 1] = '+';
		}

		if (maxperc[c] > 99) {
			sprintf(tmp, "MAX");
		} else {
			sprintf(tmp, "%02d%%", maxperc[c]);
		}

		if (c) {
			memcpy(line + bar_length + 3 + 1, tmp, 3);
		} else {
			memcpy(line + bar_length, tmp, 3);
		}
	}

	line[bar_length * 2 + 6 + 2] = 0;
	fputs(line, stderr);
}

// Display meter text line
void AlsaCore::print_vu_meter(signed int *perc, signed int *maxperc)
{
	if (vumeter == VUMETER_STEREO) {
		print_vu_meter_stereo(perc, maxperc);
	} else {
		print_vu_meter_mono(*perc, *maxperc);
	}
}

// Peak handler
void AlsaCore::compute_max_peak(unsigned char *data, size_t count)
{
	signed int val, max, perc[2], max_peak[2];
	static	int	run = 0;
	size_t ocount = count;
	int	format_little_endian = snd_pcm_format_little_endian(hwparams.format);
	int ichans, c;

	if (vumeter == VUMETER_STEREO) {
		ichans = 2;
	} else {
		ichans = 1;
	}

	memset(max_peak, 0, sizeof(max_peak));
	switch (bits_per_sample) {
	case 8:
	{
		signed char *valp = (signed char *)data;
		signed char mask = snd_pcm_format_silence(hwparams.format);
		c = 0;
		while (count-- > 0) {
			val = *valp++ ^ mask;
			val = abs(val);
			if (max_peak[c] < val) {
				max_peak[c] = val;
			}
			if (vumeter == VUMETER_STEREO) {
				c = !c;
			}
		}
		break;
	}

	case 16:
	{
		signed short *valp = (signed short *)data;
		signed short mask = snd_pcm_format_silence_16(hwparams.format);
		signed short sval;

		count /= 2;
		c = 0;
		while (count-- > 0) {
			if (format_little_endian) {
				sval = le16toh(*valp);
			} else {
				sval = be16toh(*valp);
			}
			sval = abs(sval) ^ mask;
			if (max_peak[c] < sval) {
				max_peak[c] = sval;
			}
			valp++;
			if (vumeter == VUMETER_STEREO) {
				c = !c;
			}
		}
		break;
	}

	case 24:
	{
		unsigned char *valp = data;
		signed int mask = snd_pcm_format_silence_32(hwparams.format);

		count /= 3;
		c = 0;
		while (count-- > 0) {
			if (format_little_endian) {
				val = valp[0] | (valp[1] << 8) | (valp[2] << 16);
			} else {
				val = (valp[0] << 16) | (valp[1] << 8) | valp[2];
			}

			// Correct signed bit in 32-bit value
			if (val & (1 << (bits_per_sample-1))) {
				val |= 0xff << 24; // Negate upper bits too
			}

			val = abs(val) ^ mask;
			if (max_peak[c] < val) {
				max_peak[c] = val;
			}
			valp += 3;
			if (vumeter == VUMETER_STEREO) {
				c = !c;
			}
		}
		break;
	}

	case 32:
	{
		signed int *valp = (signed int *)data;
		signed int mask = snd_pcm_format_silence_32(hwparams.format);

		count /= 4;
		c = 0;
		while (count-- > 0) {
			if (format_little_endian) {
				val = le32toh(*valp);
			} else {
				val = be32toh(*valp);
			}
			val = abs(val) ^ mask;
			if (max_peak[c] < val) {
				max_peak[c] = val;
			}
			valp++;
			if (vumeter == VUMETER_STEREO) {
				c = !c;
			}
		}
		break;
	}

	default:
		if (run == 0) {
			fprintf(stderr, _("Unsupported bit size %d.\n"), (int)bits_per_sample);
			run = 1;
		}
		return;
	}

	max = 1 << (bits_per_sample-1);
	if (max <= 0) {
		max = 0x7fffffff;
	}

	for (c = 0; c < ichans; c++) {
		if (bits_per_sample > 16) {
			perc[c] = max_peak[c] / (max / 100);
		} else {
			perc[c] = max_peak[c] * 100 / max;
		}
	}

	if (interleaved && verbose <= 2) {
		static int maxperc[2];
		static time_t t=0;
		const time_t tt=time(NULL);
		if (tt > t) {
			t = tt;
			maxperc[0] = 0;
			maxperc[1] = 0;
		}

		for (c = 0; c < ichans; c++) {
			if (perc[c] > maxperc[c]) {
				maxperc[c] = perc[c];
			}
		}

		putc('\r', stderr);
		print_vu_meter(perc, maxperc);
		fflush(stderr);
	} else if (verbose == 3) {
		fprintf(stderr, _("Max peak (%li samples): 0x%08x "), (long)ocount, max_peak[0]);
		for (val = 0; val < 20; val++) {
			if (val <= perc[0] / 5) {
				putc('#', stderr);
			} else {
				putc(' ', stderr);
			}
		}
		fprintf(stderr, " %i%%\n", perc[0]);
		fflush(stderr);
	}
}

// Test if buffer position is good and/or print out buffer info
void AlsaCore::do_test_position(void)
{
	static long counter = 0;
	static time_t tmr = -1;
	time_t now;
	static float availsum, delaysum, samples;
	static snd_pcm_sframes_t maxavail, maxdelay;
	static snd_pcm_sframes_t minavail, mindelay;
	static snd_pcm_sframes_t badavail = 0, baddelay = 0;
	snd_pcm_sframes_t outofrange;
	snd_pcm_sframes_t avail, delay;
	int err;

	err = snd_pcm_avail_delay(handle, &avail, &delay);
	if (err < 0) {
		return;
	}

	outofrange = (test_coef * (snd_pcm_sframes_t)buffer_frames) / 2;
	if (avail > outofrange || avail < -outofrange ||
			delay > outofrange || delay < -outofrange) {
		badavail = avail; baddelay = delay;
		availsum = delaysum = samples = 0;
		maxavail = maxdelay = 0;
		minavail = mindelay = buffer_frames * 16;
		fprintf(stderr, _("Suspicious buffer position (%li total): "
				"avail = %li, delay = %li, buffer = %li\n"),
				++counter, (long)avail, (long)delay, (long)buffer_frames);
	} else if (verbose) {
		time(&now);
		if (tmr == (time_t) -1) {
			tmr = now;
			availsum = delaysum = samples = 0;
			maxavail = maxdelay = 0;
			minavail = mindelay = buffer_frames * 16;
		}

		if (avail > maxavail) {
			maxavail = avail;
		}

		if (delay > maxdelay) {
			maxdelay = delay;
		}

		if (avail < minavail) {
			minavail = avail;
		}

		if (delay < mindelay) {
			mindelay = delay;
		}

		availsum += avail;
		delaysum += delay;
		samples++;

		if (avail != 0 && now != tmr) {
			fprintf(stderr, "BUFPOS: avg%li/%li "
					"min%li/%li max%li/%li (%li) (%li:%li/%li)\n",
					(long)(availsum / samples),
					(long)(delaysum / samples),
					(long)minavail, (long)mindelay,
					(long)maxavail, (long)maxdelay,
					(long)buffer_frames,
					counter, badavail, baddelay);
			tmr = now;
		}
	}
}

#ifdef CONFIG_SUPPORT_CHMAP
// Re-map data in memory
unsigned char* AlsaCore::remap_data(unsigned char *data, size_t count)
{
	static unsigned char *tmp, *src, *dst;
	static size_t tmp_size;
	size_t sample_bytes = bits_per_sample / 8;
	size_t step = bits_per_frame / 8;
	size_t chunk_bytes;
	unsigned int ch, i;

	if (!hw_map) {
		return (data);
	}

	chunk_bytes = count * bits_per_frame / 8;
	if (tmp_size < chunk_bytes) {
		free(tmp);
		tmp = (unsigned char *)malloc(chunk_bytes);
		if (!tmp) {
			error(_("not enough memory"));
			exit(1);
		}
		tmp_size = count;
	}

	src = data;
	dst = tmp;
	for (i = 0; i < count; i++) {
		for (ch = 0; ch < hwparams.channels; ch++) {
			memcpy(dst, src + sample_bytes * hw_map[ch],
					sample_bytes);
			dst += sample_bytes;
		}
		src += step;
	}

	return (tmp);
}

// Re-map data for all channels
unsigned char** AlsaCore::remap_datav(unsigned char **data, size_t count)
{
	static unsigned char **tmp;
	unsigned int ch;

	if (!hw_map) {
		return (data);
	}

	if (!tmp) {
		tmp = (unsigned char **)malloc(sizeof(*tmp) * hwparams.channels);
		if (!tmp) {
			error(_("not enough memory"));
			exit(1);
		}

		for (ch = 0; ch < hwparams.channels; ch++) {
			tmp[ch] = data[hw_map[ch]];
		}
	}

	return (tmp);
}
#else
#define remap_data(data, count)		(data)
#define remap_datav(data, count)	(data)
#endif

// PCM write channel
ssize_t AlsaCore::pcm_write(unsigned char *data, size_t count)
{
	ssize_t r;
	ssize_t result = 0;

	if (count < chunk_size) {
		snd_pcm_format_set_silence(hwparams.format, data + count * bits_per_frame / 8, (chunk_size - count) * hwparams.channels);
		count = chunk_size;
	}

	data = remap_data(data, count);
	while (count > 0 && !in_aborting) {
		if (test_position) {
			do_test_position();
		}

		check_stdin();
		r = writei_func(handle, data, count);

		if (test_position) {
			do_test_position();
		}

		if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) {
			if (!test_nowait) {
				snd_pcm_wait(handle, 100);
			}
		} else if (r == -EPIPE) {
			xrun_record();
		} else if (r == -ESTRPIPE) {
			suspend();
		} else if (r < 0) {
			error(_("write error: %s"), snd_strerror(r));
			prg_exit(EXIT_FAILURE);
		}

		if (r > 0) {
			if (vumeter) {
				compute_max_peak(data, r * hwparams.channels);
			}
			result += r;
			count  -= r;
			data   += r * bits_per_frame / 8;
		}
	}

	return (result);
}

// PCM write channels
ssize_t AlsaCore::pcm_writev(unsigned char **data, unsigned int channels, size_t count)
{
	ssize_t r;
	size_t result = 0;

	if (count != chunk_size) {
		unsigned int channel;
		size_t offset = count;
		size_t remaining = chunk_size - count;

		for (channel = 0; channel < channels; channel++) {
			snd_pcm_format_set_silence(hwparams.format, data[channel] + offset * bits_per_sample / 8, remaining);
		}

		count = chunk_size;
	}

	data = remap_datav(data, count);
	while (count > 0 && !in_aborting) {
		unsigned int channel;
		void *bufs[channels];
		size_t offset = result;

		for (channel = 0; channel < channels; channel++) {
			bufs[channel] = data[channel] + offset * bits_per_sample / 8;
		}

		if (test_position) {
			do_test_position();
		}

		check_stdin();
		r = writen_func(handle, bufs, count);

		if (test_position) {
			do_test_position();
		}

		if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) {
			if (!test_nowait) {
				snd_pcm_wait(handle, 100);
			}
		} else if (r == -EPIPE) {
			xrun_record();
		} else if (r == -ESTRPIPE) {
			suspend();
		} else if (r < 0) {
			error(_("writev error: %s"), snd_strerror(r));
			prg_exit(EXIT_FAILURE);
		}

		if (r > 0) {
			if (vumeter) {
				for (channel = 0; channel < channels; channel++)
					compute_max_peak(data[channel], r);
			}
			result += r;
			count -= r;
		}
	}

	return (result);
}

// Read channel
ssize_t AlsaCore::pcm_read(unsigned char *data, size_t rcount)
{
	ssize_t r;
	size_t result = 0;
	size_t count = rcount;

	if (count != chunk_size) {
		count = chunk_size;
	}

	while (count > 0 && !in_aborting) {
		if (test_position) {
			do_test_position();
		}

		check_stdin();
		r = readi_func(handle, data, count);

		if (test_position) {
			do_test_position();
		}

		if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) {
			if (!test_nowait) {
				snd_pcm_wait(handle, 100);
			}
		} else if (r == -EPIPE) {
			xrun_record();
		} else if (r == -ESTRPIPE) {
			suspend();
		} else if (r < 0) {
			error(_("read error: %s"), snd_strerror(r));
			prg_exit(EXIT_FAILURE);
		}

		if (r > 0) {
			if (vumeter) {
				compute_max_peak(data, r * hwparams.channels);
			}
			result += r;
			count  -= r;
			data   += r * bits_per_frame / 8;
		}
	}

	return (result);
}

// PCM Read channels
ssize_t AlsaCore::pcm_readv(unsigned char **data, unsigned int channels, size_t rcount)
{
	ssize_t r;
	size_t result = 0;
	size_t count = rcount;

	if (count != chunk_size) {
		count = chunk_size;
	}

	while (count > 0 && !in_aborting) {
		unsigned int channel;
		void *bufs[channels];
		size_t offset = result;

		for (channel = 0; channel < channels; channel++) {
			bufs[channel] = data[channel] + offset * bits_per_sample / 8;
		}

		if (test_position) {
			do_test_position();
		}

		check_stdin();
		r = readn_func(handle, bufs, count);

		if (test_position) {
			do_test_position();
		}

		if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) {
			if (!test_nowait) {
				snd_pcm_wait(handle, 100);
			}
		} else if (r == -EPIPE) {
			xrun_record();
		} else if (r == -ESTRPIPE) {
			suspend();
		} else if (r < 0) {
			error(_("readv error: %s"), snd_strerror(r));
			prg_exit(EXIT_FAILURE);
		}

		if (r > 0) {
			if (vumeter) {
				for (channel = 0; channel < channels; channel++) {
					compute_max_peak(data[channel], r);
				}
			}
			result += r;
			count -= r;
		}
	}

	return (result);
}

// Read channel data
ssize_t AlsaCore::pcm_channel_read(unsigned char *data, size_t rcount)
{
    ssize_t r;
    size_t result = 0;
    size_t count = rcount;
    snd_pcm_uframes_t chunk_size = DEFAULT_CHUNK_SIZE;
    size_t bits_per_sample = snd_pcm_format_physical_width(hwparams.format);
    size_t bits_per_frame = bits_per_sample * hwparams.channels;

    if (count != chunk_size) {
        count = chunk_size;
    }

    while (count > 0 && !in_aborting) {
        check_stdin();
        r = readi_func(handle, data, count);

        if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) {
            if (!test_nowait) {
                snd_pcm_wait(handle, 100);
            }
        } else if (r == -EPIPE) {
            xrun_record();
        } else if (r == -ESTRPIPE) {
            suspend();
        } else if (r < 0) {
            error(_("read error: %s"), snd_strerror(r));
            prg_exit(EXIT_FAILURE);
        }

        if (r > 0) {
            result += r;
            count  -= r;
            data   += r * bits_per_frame / 8;
        }
    }

    return (result);
}

// Play a VOC file
ssize_t AlsaCore::voc_pcm_write(unsigned char *data, size_t count)
{
	ssize_t result = count, r;
	size_t size;

	while (count > 0) {
		size = count;
		if (size > chunk_bytes - buffer_pos) {
			size = chunk_bytes - buffer_pos;
		}
		memcpy(audiobuf + buffer_pos, data, size);
		data += size;
		count -= size;
		buffer_pos += size;
		if ((size_t)buffer_pos == chunk_bytes) {
			if ((size_t)(r = pcm_write(audiobuf, chunk_size)) != chunk_size) {
				return (r);
			}
			buffer_pos = 0;
		}
	}

	return (result);
}

// VOC silence
void AlsaCore::voc_write_silence(unsigned x)
{
	unsigned l;
	unsigned char *buf;

	buf = (unsigned char *)malloc(chunk_bytes);
	if (buf == NULL) {
		error(_("can't allocate buffer for silence"));
		return;		// Not fatal error
	}

	snd_pcm_format_set_silence(hwparams.format, buf, chunk_size * hwparams.channels);

	while (x > 0 && !in_aborting) {
		l = x;
		if (l > chunk_size) {
			l = chunk_size;
		}
		if (voc_pcm_write(buf, l) != (ssize_t)l) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}
		x -= l;
	}

	free(buf);
}

// Flush VOC pcm
void AlsaCore::voc_pcm_flush(void)
{
	if (buffer_pos > 0) {
		size_t b;

		if (snd_pcm_format_set_silence(hwparams.format, audiobuf + buffer_pos, chunk_bytes - buffer_pos * 8 / bits_per_sample) < 0) {
			fprintf(stderr, _("voc_pcm_flush - silence error"));
		}

		b = chunk_size;

		if (pcm_write(audiobuf, b) != (ssize_t)b) {
			error(_("voc_pcm_flush error"));
		}
	}

	snd_pcm_nonblock(handle, 0);
	snd_pcm_drain(handle);
	snd_pcm_nonblock(handle, nonblock);
}

// Play VOC
void AlsaCore::voc_play(int fd, int ofs, char *name)
{
	int l;
	VocBlockType *bp;
	VocVoiceData *vd;
	VocExtBlock *eb;
	size_t nextblock, in_buffer;
	unsigned char *data, *buf;
	char was_extended = 0, output = 0;
	u_short *sp, repeat = 0;
	off64_t filepos = 0;

#define COUNT(x)	nextblock -= x; in_buffer -= x; data += x
#define COUNT1(x)	in_buffer -= x; data += x

	data = buf = (unsigned char *)malloc(64 * 1024);
	buffer_pos = 0;
	if (data == NULL) {
		error(_("malloc error"));
		prg_exit(EXIT_FAILURE);
	}

	if (!quiet_mode) {
		fprintf(stderr, _("Playing Creative Labs Channel file '%s'...\n"), name);
	}

	// First we waste the rest of header, ugly but we don't need seek
	while (ofs > (ssize_t)chunk_bytes) {
		if ((size_t)safe_read(fd, buf, chunk_bytes) != chunk_bytes) {
			error(_("read error"));
			prg_exit(EXIT_FAILURE);
		}
		ofs -= chunk_bytes;
	}

	if (ofs) {
		if (safe_read(fd, buf, ofs) != ofs) {
			error(_("read error"));
			prg_exit(EXIT_FAILURE);
		}
	}

	hwparams.format = DEFAULT_FORMAT;
	hwparams.channels = 1;
	hwparams.rate = DEFAULT_SPEED;
	set_play_params();

	in_buffer = nextblock = 0;
	while (!in_aborting) {
		Fill_the_buffer: // Need this for repeat
		if (in_buffer < 32) {
			// Move the rest of buffer to pos 0 and fill the buf up
			if (in_buffer) {
				memcpy(buf, data, in_buffer);
			}
			data = buf;
			if ((l = safe_read(fd, buf + in_buffer, chunk_bytes - in_buffer)) > 0) {
				in_buffer += l;
			} else if (!in_buffer) {
				// The file is truncated, so simulate 'Terminator'
				// and reduce the datablock for safe landing
				nextblock = buf[0] = 0;
				if (l == -1) {
					perror(name);
					prg_exit(EXIT_FAILURE);
				}
			}
		}

		while (!nextblock) {
			// This is a new block
			if (in_buffer < sizeof(VocBlockType)) {
				goto __end;
			}
			bp = (VocBlockType *) data;
			COUNT1(sizeof(VocBlockType));
			nextblock = VOC_DATALEN(bp);
			if (output && !quiet_mode) {
				fprintf(stderr, "\n");	// Write /n after ASCII-out
			}
			output = 0;
			switch (bp->type) {
			case 0:
#if 0
				d_printf("Terminator\n");
#endif
				return;		// VOC-file stop

			case 1:
				vd = (VocVoiceData *) data;
				COUNT1(sizeof(VocVoiceData));
				// we need a SYNC, before we can set new SPEED, STEREO ...

				if (!was_extended)
				{
					hwparams.rate = (int) (vd->tc);
					hwparams.rate = 1000000 / (256 - hwparams.rate);
#if 0
					d_printf("Channel data %d Hz\n", dsp_speed);
#endif
					if (vd->pack) {
						// /dev/dsp can't it
						error(_("can't play packed .voc files"));
						return;
					}

					// if we are in Stereo-Mode, switch back
					if (hwparams.channels == 2) {
						hwparams.channels = 1;
					}
				}
				else
				{
					// There was extended block
					hwparams.channels = 2;
					was_extended = 0;
				}
				set_play_params();
				break;

			case 2:	// nothing to do, pure data
#if 0
				d_printf("Channel continuation\n");
#endif
				break;

			case 3:	// a silence block, no data, only a count
				sp = (u_short *) data;
				COUNT1(sizeof(u_short));
				hwparams.rate = (int) (*data);
				COUNT1(1);
				hwparams.rate = 1000000 / (256 - hwparams.rate);
				set_play_params();
#if 0
				{
					size_t silence;
					silence = (((size_t) * sp) * 1000) / hwparams.rate;
					d_printf("Silence for %d ms\n", (int) silence);
				}
#endif
				voc_write_silence(*sp);
				break;

			case 4:	// a marker for syncronisation, no effect
				sp = (u_short *) data;
				COUNT1(sizeof(u_short));
#if 0
				d_printf("Marker %d\n", *sp);
#endif
				break;

			case 5:	// ASCII text, we copy to stderr
				output = 1;
#if 0
				d_printf("ASCII - text :\n");
#endif
				break;

			case 6:	// repeat marker, says repeatcount
				// my specs don't say it: maybe this can be recursive, but
				// I don't think somebody use it
				repeat = *(u_short *) data;
				COUNT1(sizeof(u_short));
#if 0
				d_printf("Repeat loop %d times\n", repeat);
#endif
				if (filepos >= 0) {
					// if < 0, one seek fails, why test another
					if ((filepos = lseek64(fd, 0, 1)) < 0) {
						error(_("can't play loops; %s isn't seekable\n"), name);
						repeat = 0;
					} else {
						filepos -= in_buffer;	// set filepos after repeat
					}
				} else {
					repeat = 0;
				}
				break;

			case 7:	// Repeat that be rewinding tape
				if (repeat) {
					if (repeat != 0xFFFF) {
#if 0
						d_printf("Repeat loop %d\n", repeat);
#endif
						--repeat;
					}
#if 0
					else
						d_printf("Neverending loop\n");
#endif
					lseek64(fd, filepos, 0);
					in_buffer = 0;	// clear the buffer
					goto Fill_the_buffer;
				}
#if 0
				else
					d_printf("End repeat loop\n");
#endif
				break;

			case 8:	// the extension to play Stereo, I have SB 1.0 :-(
				was_extended = 1;
				eb = (VocExtBlock *) data;
				COUNT1(sizeof(VocExtBlock));
				hwparams.rate = (int) (eb->tc);
				hwparams.rate = 256000000L / (65536 - hwparams.rate);
				hwparams.channels = eb->mode == VOC_MODE_STEREO ? 2 : 1;
				if (hwparams.channels == 2) {
					hwparams.rate = hwparams.rate >> 1;
				}

				if (eb->pack) {
					// /dev/dsp can't it
					error(_("can't play packed .voc files"));
					return;
				}
#if 0
				d_printf("Extended block %s %d Hz\n",
						(eb->mode ? "Stereo" : "Mono"), dsp_speed);
#endif
				break;

			default:
				error(_("unknown blocktype %d. terminate."), bp->type);
				return;
			}	// switch (bp->type)
		}		// while (! nextblock)

		// Put nextblock data bytes to dsp
		l = in_buffer;
		if (nextblock < (size_t)l) {
			l = nextblock; }

		if (l) {
			if (output && !quiet_mode) {
				if (write(2, data, l) != l) {
					// to stderr
					error(_("write error"));
					prg_exit(EXIT_FAILURE);
				}
			} else {
				if (voc_pcm_write(data, l) != l) {
					error(_("write error"));
					prg_exit(EXIT_FAILURE);
				}
			}
			COUNT(l);
		}
	} // while (!in_aborting)

	__end:
	voc_pcm_flush();
	free(buf);
}

// Setting the globals for playing raw data
void AlsaCore::init_raw_data(void)
{
	hwparams = rhwparams;
}

// Write a .VOC-header
void AlsaCore::begin_voc(int fd, size_t cnt)
{
	VocHeader vh;
	VocBlockType bt;
	VocVoiceData vd;
	VocExtBlock eb;

	memcpy(vh.magic, VOC_MAGIC_STRING, 20);
	vh.headerlen = LE_SHORT(sizeof(VocHeader));
	vh.version = LE_SHORT(VOC_ACTUAL_VERSION);
	vh.coded_ver = LE_SHORT(0x1233 - VOC_ACTUAL_VERSION);

	if (write(fd, &vh, sizeof(VocHeader)) != sizeof(VocHeader)) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}

	if (hwparams.channels > 1) {
		// Write an extended block
		bt.type = 8;
		bt.datalen = 4;
		bt.datalen_m = bt.datalen_h = 0;
		if (write(fd, &bt, sizeof(VocBlockType)) != sizeof(VocBlockType)) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}

		eb.tc = LE_SHORT(65536 - 256000000L / (hwparams.rate << 1));
		eb.pack = 0;
		eb.mode = 1;
		if (write(fd, &eb, sizeof(VocExtBlock)) != sizeof(VocExtBlock)) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}
	}

	bt.type = 1;
	cnt += sizeof(VocVoiceData); // Channel_data block follows
	bt.datalen = (unsigned char) (cnt & 0xFF);
	bt.datalen_m = (unsigned char) ((cnt & 0xFF00) >> 8);
	bt.datalen_h = (unsigned char) ((cnt & 0xFF0000) >> 16);
	if (write(fd, &bt, sizeof(VocBlockType)) != sizeof(VocBlockType)) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}

	vd.tc = (unsigned char) (256 - (1000000 / hwparams.rate));
	vd.pack = 0;
	if (write(fd, &vd, sizeof(VocVoiceData)) != sizeof(VocVoiceData)) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}
}

// write a WAVE-header
void AlsaCore::begin_wave(int fd, size_t cnt)
{
	WaveHeader h;
	WaveFmtBody f;
	WaveChunkHeader cf, cd;
	int bits;
	u_int tmp;
	u_short tmp2;

	// WAVE cannot handle greater than 32bit (signed?) int
	if (cnt == (size_t)-2) {
		cnt = 0x7fffff00;
	}

	bits = 8;
	switch ((unsigned long) hwparams.format) {
	case SND_PCM_FORMAT_U8:
		bits = 8;
		break;

	case SND_PCM_FORMAT_S16_LE:
		bits = 16;
		break;

	case SND_PCM_FORMAT_S32_LE:
	case SND_PCM_FORMAT_FLOAT_LE:
		bits = 32;
		break;

	case SND_PCM_FORMAT_S24_LE:
	case SND_PCM_FORMAT_S24_3LE:
		bits = 24;
		break;

	default:
		error(_("Wave doesn't support %s format..."), snd_pcm_format_name(hwparams.format));
		prg_exit(EXIT_FAILURE);
	}

	h.magic = WAV_RIFF;
	tmp = cnt + sizeof(WaveHeader) + sizeof(WaveChunkHeader) + sizeof(WaveFmtBody) + sizeof(WaveChunkHeader) - 8;
	h.length = LE_INT(tmp);
	h.type = WAV_WAVE;
	cf.type = WAV_FMT;
	cf.length = LE_INT(16);

	if (hwparams.format == SND_PCM_FORMAT_FLOAT_LE) {
		f.format = LE_SHORT(WAV_FMT_IEEE_FLOAT);
	} else {
		f.format = LE_SHORT(WAV_FMT_PCM);
	}

	f.channels = LE_SHORT(hwparams.channels);
	f.sample_fq = LE_INT(hwparams.rate);

	tmp2 = hwparams.channels * snd_pcm_format_physical_width(hwparams.format) / 8;
	f.byte_p_spl = LE_SHORT(tmp2);
	tmp = (u_int) tmp2 * hwparams.rate;

	f.byte_p_sec = LE_INT(tmp);
	f.bit_p_spl = LE_SHORT(bits);

	cd.type = WAV_DATA;
	cd.length = LE_INT(cnt);

	if (write(fd, &h,  sizeof(WaveHeader)) 		!= sizeof(WaveHeader) ||
			write(fd, &cf, sizeof(WaveChunkHeader)) != sizeof(WaveChunkHeader) ||
			write(fd, &f,  sizeof(WaveFmtBody)) 	!= sizeof(WaveFmtBody) ||
			write(fd, &cd, sizeof(WaveChunkHeader)) != sizeof(WaveChunkHeader)) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}
}

// Write a Au-header
void AlsaCore::begin_au(int fd, size_t cnt)
{
	AuHeader ah;
	ah.magic = AU_MAGIC;
	ah.hdr_size = BE_INT(24);
	ah.data_size = BE_INT(cnt);
	switch ((unsigned long) hwparams.format) {
	case SND_PCM_FORMAT_MU_LAW:
		ah.encoding = BE_INT(AU_FMT_ULAW);
		break;

	case SND_PCM_FORMAT_U8:
		ah.encoding = BE_INT(AU_FMT_LIN8);
		break;

	case SND_PCM_FORMAT_S16_BE:
		ah.encoding = BE_INT(AU_FMT_LIN16);
		break;

	default:
		error(_("Sparc Audio doesn't support %s format..."), snd_pcm_format_name(hwparams.format));
		prg_exit(EXIT_FAILURE);
	}

	ah.sample_rate = BE_INT(hwparams.rate);
	ah.channels = BE_INT(hwparams.channels);
	if (write(fd, &ah, sizeof(AuHeader)) != sizeof(AuHeader)) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}
}

// Closing .VOC
void AlsaCore::end_voc(int fd)
{
	off64_t length_seek;
	VocBlockType bt;
	size_t cnt;
	char dummy = 0; // Write a Terminator
	ssize_t size;

	if (write(fd, &dummy, 1) != 1) {
		error(_("write error"));
		prg_exit(EXIT_FAILURE);
	}

	length_seek = sizeof(VocHeader);
	if (hwparams.channels > 1) {
		length_seek += sizeof(VocBlockType) + sizeof(VocExtBlock);
	}
	bt.type = 1;
	cnt = fdcount;
	cnt += sizeof(VocVoiceData); // Channel_data block follows
	if (cnt > 0x00ffffff)
		cnt = 0x00ffffff;

	bt.datalen = (unsigned char) (cnt & 0xFF);
	bt.datalen_m = (unsigned char) ((cnt & 0xFF00) >> 8);
	bt.datalen_h = (unsigned char) ((cnt & 0xFF0000) >> 16);
	if (lseek64(fd, length_seek, SEEK_SET) == length_seek) {
		size = write(fd, &bt, sizeof(VocBlockType));
		if (size == 0) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}
	}

	if (fd != 1) {
		close(fd);
	}
}

// Closing wav file
void AlsaCore::end_wave(int fd)
{
	// Only close output
	WaveChunkHeader cd;
	off64_t length_seek;
	off64_t filelen;
	u_int rifflen;
	ssize_t size;

	length_seek = sizeof(WaveHeader) +
				  sizeof(WaveChunkHeader) +
				  sizeof(WaveFmtBody);
	cd.type = WAV_DATA;
	cd.length = fdcount > 0x7fffffff ? LE_INT(0x7fffffff) : LE_INT(fdcount);
	filelen = fdcount + 2*sizeof(WaveChunkHeader) + sizeof(WaveFmtBody) + 4;
	rifflen = filelen > 0x7fffffff ? LE_INT(0x7fffffff) : LE_INT(filelen);

	if (lseek64(fd, 4, SEEK_SET) == 4) {
		size = write(fd, &rifflen, 4);
		if (size == 0) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}
	}

	if (lseek64(fd, length_seek, SEEK_SET) == length_seek) {
		size = write(fd, &cd, sizeof(WaveChunkHeader));
		if (size == 0) {
			error(_("write error"));
			prg_exit(EXIT_FAILURE);
		}
	}

	if (fd != 1) {
		close(fd);
	}
}

// Closing au
void AlsaCore::end_au(int fd)
{
	// only close output
	AuHeader ah;
	off64_t length_seek;
	ssize_t size;

	length_seek = (char *)&ah.data_size - (char *)&ah;
	ah.data_size = fdcount > 0xffffffff ? 0xffffffff : BE_INT(fdcount);

	if (lseek64(fd, length_seek, SEEK_SET) == length_seek) {
		size = write(fd, &ah.data_size, sizeof(ah.data_size));
		if (size == 0) {
			close(fd);
			return;
		}
	}

	if (fd != 1) {
		close(fd);
	}
}

// Display file header information
void AlsaCore::header(int rtype, char *name)
{
	if (!quiet_mode) {
		if (! name) {
			name = (char *)((stream == SND_PCM_STREAM_PLAYBACK) ? "stdout" : "stdin");
		}

		fprintf(stderr, "%s %s '%s' : ",
				(stream == SND_PCM_STREAM_PLAYBACK) ? _("Playing") : _("Recording"),
						gettext(fmt_rec_table[rtype].what),
						name);

		fprintf(stderr, "%s, ", snd_pcm_format_description(hwparams.format));
		fprintf(stderr, _("Rate %d Hz, "), hwparams.rate);
		if (hwparams.channels == 1) {
			fprintf(stderr, _("Mono"));
		}
		else if (hwparams.channels == 2) {
			fprintf(stderr, _("Stereo"));
		}
		else {
			fprintf(stderr, _("Channels %i"), hwparams.channels);
		}
		fprintf(stderr, "\n");
	}
}

// Play raw data
void AlsaCore::playback_go(int fd, size_t loaded, off64_t count,
		int rtype, char *name)
{
	int l, r;
	off64_t written = 0;
	off64_t c;

	header(rtype, name);
	set_play_params();

	while (loaded > chunk_bytes && written < count && !in_aborting) {
		if (pcm_write(audiobuf + written, chunk_size) <= 0)
			return;
		written += chunk_bytes;
		loaded -= chunk_bytes;
	}

	if (written > 0 && loaded > 0) {
		memmove(audiobuf, audiobuf + written, loaded);
	}

	l = loaded;
	while (written < count && !in_aborting) {
		do {
			c = count - written;
			if (c > chunk_bytes) {
				c = chunk_bytes;
			}
			c -= l;

			if (c == 0) {
				break;
			}

			r = safe_read(fd, audiobuf + l, c);
			if (r < 0) {
				perror(name);
				prg_exit(EXIT_FAILURE);
			}
			fdcount += r;

			if (r == 0) {
				break;
			}

			l += r;
		}
		while ((size_t)l < chunk_bytes);

		l = l * 8 / bits_per_frame;
		r = pcm_write(audiobuf, l);
		if (r != l) {
			break;
		}
		r = r * bits_per_frame / 8;
		written += r;
		l = 0;
	}

	snd_pcm_nonblock(handle, 0);
	snd_pcm_drain(handle);
	snd_pcm_nonblock(handle, nonblock);

	fprintf(stderr, "Finished play back wave file %s\n", name);
}

// Let's play or capture it (capture_type says VOC/WAVE/raw)
void AlsaCore::playback(char *name)
{
	int ofs;
	size_t dta;
	ssize_t dtawave;

	pbrec_count = LLONG_MAX;
	fdcount = 0;
	if (!name || !strcmp(name, "-")) {
		fd = fileno(stdin);
		name = (char *)"stdin";
	} else {
		init_stdin();
		if ((fd = open(name, O_RDONLY, 0)) == -1) {
			perror(name);
			prg_exit(EXIT_FAILURE);
		}
	}

	// Read the file header
	dta = sizeof(AuHeader);
	if ((size_t)safe_read(fd, audiobuf, dta) != dta) {
		error(_("read error"));
		prg_exit(EXIT_FAILURE);
	}

	if (test_au(fd, audiobuf) >= 0) {
		rhwparams.format = hwparams.format;
		pbrec_count = calc_count();
		playback_go(fd, 0, pbrec_count, FORMAT_AU, name);
		goto __end;
	}

	dta = sizeof(VocHeader);
	if ((size_t)safe_read(fd, audiobuf + sizeof(AuHeader),
			dta - sizeof(AuHeader)) != dta - sizeof(AuHeader)) {
		error(_("read error"));
		prg_exit(EXIT_FAILURE);;
	}

	if ((ofs = test_vocfile(audiobuf)) >= 0) {
		pbrec_count = calc_count();
		voc_play(fd, ofs, name);
		goto __end;
	}

	// Read bytes for WAVE-header
	if ((dtawave = test_wavefile(fd, audiobuf, dta)) >= 0) {
		pbrec_count = calc_count();
		playback_go(fd, dtawave, pbrec_count, FORMAT_WAVE, name);
	} else {
		// Should be raw data
		init_raw_data();
		pbrec_count = calc_count();
		playback_go(fd, dta, pbrec_count, FORMAT_RAW, name);
	}

	__end:
	if (fd != 0) {
		close(fd);
	}
}

// Time string formatting method
//
//   Variant of strftime(3) that supports additional format
//   specifiers in the format string.
//
// Parameters:
//
//   s	  		- destination string
//   max		- max number of bytes to write
//   userformat - format string
//   tm	 		- time information
//   filenumber - the number of the file, starting at 1
//
// Returns: number of bytes written to the string s
size_t AlsaCore::mystrftime(char *s, size_t max, const char *userformat,
		const struct tm *tm, const int filenumber)
{
	char formatstring[PATH_MAX] = "";
	char tempstring[PATH_MAX] = "";
	char *format, *tempstr;
	const char *pos_userformat;

	format = formatstring;

	// If mystrftime is called with userformat = NULL we return a zero length string
	if (userformat == NULL) {
		*s = '\0';
		return (0);
	}

	for (pos_userformat = userformat; *pos_userformat; ++pos_userformat) {
		if (*pos_userformat == '%') {
			tempstr = tempstring;
			tempstr[0] = '\0';
			switch (*++pos_userformat) {
			case '\0': // end of string
				--pos_userformat;
				break;

			case 'v': // file number
				sprintf(tempstr, "%02d", filenumber);
				break;

			default: // All other codes will be handled by strftime
				*format++ = '%';
				*format++ = *pos_userformat;
				continue;
			}

			// If a format specifier was found and used, copy the result
			if (tempstr[0]) {
				while ((*format = *tempstr++) != '\0')
					++format;
				continue;
			}
		}

		// For any other character than % we simply copy the character
		*format++ = *pos_userformat;
	}

	*format = '\0';
	format = formatstring;
	return (strftime(s, max, format, tm));
}

// Create and display new file time
int AlsaCore::new_capture_file_strftime(char *name, char *namebuf,
		size_t namelen, int filecount)
{
	char *s;
	char buf[PATH_MAX+1];
	time_t t;
	struct tm *tmp;

	if (use_strftime) {
		t = time(NULL);
		tmp = localtime(&t);
		if (tmp == NULL) {
			perror("localtime");
			prg_exit(EXIT_FAILURE);
		}

		if (mystrftime(namebuf, namelen, name, tmp, filecount+1) == 0) {
			fprintf(stderr, "mystrftime returned 0");
			prg_exit(EXIT_FAILURE);
		}

		return (filecount);
	}

	// Get a copy of the original filename
	strncpy(buf, name, sizeof(buf));

	// Separate extension from filename
	s = buf + strlen(buf);
	while (s > buf && *s != '.' && *s != '/')
		--s;
	if (*s == '.') {
		*s++ = 0;
	} else if (*s == '/') {
		s = buf + strlen(buf);
	}

	// Upon first jump to this if block rename the first file
	if (filecount == 1) {
		if (*s) {
			snprintf(namebuf, namelen, "%s-01.%s", buf, s);
		} else {
			snprintf(namebuf, namelen, "%s-01", buf);
		}

		remove(namebuf);
		rename(name, namebuf);
		filecount = 2;
	}

	// Name of the current file
	if (*s) {
		snprintf(namebuf, namelen, "%s-%02i.%s", buf, filecount, s);
	} else {
		snprintf(namebuf, namelen, "%s-%02i", buf, filecount);
	}

	return (filecount);
}

// Creates a file path, like mkdir -p
int AlsaCore::create_path(const char *path)
{
	char *start;
	mode_t mode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;

	if (path[0] == '/') {
		start = (char *)strchr(path + 1, '/');
	} else {
		start = (char *)strchr(path, '/');
	}

	while (start) {
		char *buffer = strdup(path);
		buffer[start-path] = 0x00;

		if (mkdir(buffer, mode) == -1 && errno != EEXIST) {
			fprintf(stderr, "Problem creating directory %s", buffer);
			perror(" ");
			free(buffer);
			return (-1);
		}

		free(buffer);
		start = (char *)strchr(start + 1, '/');
	}

	return (0);
}

// Thread safe open
int AlsaCore::safe_open(const char *name)
{
	int fd;

	fd = open(name, O_WRONLY | O_CREAT, 0644);
	if (fd == -1) {
		if (errno != ENOENT || !use_strftime) {
			return (-1);
		}
		if (create_path(name) == 0) {
			fd = open(name, O_WRONLY | O_CREAT, 0644);
		}
	}

	return (fd);
}

// Capture pcm audio from record device
void AlsaCore::capture(char *orig_name)
{
	bool tostdout = false;	// boolean which describes output stream
	int filecount = 0;		// number of files written
	char *name = orig_name;	// current filename
	char namebuf[PATH_MAX+1];
	off64_t count, rest;	// number of bytes to capture

	// get number of bytes to capture
	count = calc_count();
	if (count == 0) {
		count = LLONG_MAX;
	}

	// WAVE-file should be even (I'm not sure), but wasting one byte
	// isn't a problem (this can only be in 8 bit mono)
	if (count < LLONG_MAX) {
		count += count % 2;
	} else {
		count -= count % 2;
	}

	printf("arecord: Recording audio to ring buffer: %s\n", name);

	// setup sound hardware
	set_record_params();

	// Write to stdout
	if (!name || !strcmp(name, "-")) {
		fd = fileno(stdout);
		name = (char *)"stdout";
		tostdout = false;
		if (count > fmt_rec_table[file_type].max_filesize) {
			count = fmt_rec_table[file_type].max_filesize;
		}
	}

	do {
		// open a file to write
		if (!tostdout) {
			// upon the second file we start the numbering scheme
			if (filecount) {
				filecount = new_capture_file(orig_name, namebuf,
						sizeof(namebuf), filecount);
				name = namebuf;
			}

			// Open a new file
			remove(name);
			if ((fd = open64(name, O_WRONLY | O_CREAT, 0644)) == -1) {
				perror(name);
				exit(EXIT_FAILURE);
			}

			filecount++;
		}

		rest = count;
		if (rest > fmt_rec_table[file_type].max_filesize) {
			rest = fmt_rec_table[file_type].max_filesize;
		}

		// Setup sample header
		if (fmt_rec_table[file_type].start) {
			fmt_rec_table[file_type].start((void*)this, fd, rest);
		}

		// Capture
		fdcount = 0;
		do {
			size_t c = (rest <= (off64_t)chunk_bytes) ? (size_t)rest : chunk_bytes;
			size_t f = c * 8 / bits_per_frame;

			if (((pcm_read(audiobuf, f)) != (ssize_t)f) && (rest == 0)) {
				break;
			}

			if ((write(fd, audiobuf, c)) != (ssize_t)c) {
				perror(name);
				exit(EXIT_FAILURE);
			}

			count -= c;
			rest -= c;
			fdcount += c;

		} while (rest > 0 && capture_stop == 0);

		// Finish sample container
		if (fmt_rec_table[file_type].end && !tostdout) {
			printf("arecord: Finished sample container\n");

			fmt_rec_table[file_type].end((void*)this, fd);
			fd = -1;
		}

		// Repeat the loop when format is raw without timelimit or
		// requested counts of data are recorded
	} while (((file_type == FORMAT_RAW && !timelimit) || count > 0) && capture_stop == 0);

	printf("arecord: Stopping capturing audio. count=%llu capture_stop=%d\n", count, capture_stop);
}

// Playback raw PCM data
void AlsaCore::playbackv_go(int* fds, unsigned int channels, size_t loaded,
		off64_t count, int rtype, char **names)
{
	int r;
	size_t vsize;

	unsigned int channel;
	unsigned char *bufs[channels];

	header(rtype, names[0]);
	set_play_params();

	vsize = chunk_bytes / channels;

	// Not yet implemented
	assert(loaded == 0);

	for (channel = 0; channel < channels; ++channel) {
		bufs[channel] = audiobuf + vsize * channel;
	}

	while (count > 0 && !in_aborting) {
		size_t c = 0;
		size_t expected = count / channels;
		if (expected > vsize) {
			expected = vsize;
		}

		do {
			r = safe_read(fds[0], bufs[0], expected);
			if (r < 0) {
				perror(names[channel]);
				prg_exit(EXIT_FAILURE);
			}

			for (channel = 1; channel < channels; ++channel) {
				if (safe_read(fds[channel], bufs[channel], r) != r) {
					perror(names[channel]);
					prg_exit(EXIT_FAILURE);
				}
			}

			if (r == 0) {
				break;
			}
			c += r;
		} while (c < expected);

		c = c * 8 / bits_per_sample;
		r = pcm_writev(bufs, channels, c);
		if ((size_t)r != c) {
			break;
		}
		r = r * bits_per_frame / 8;
		count -= r;
	}

	snd_pcm_nonblock(handle, 0);
	snd_pcm_drain(handle);
	snd_pcm_nonblock(handle, nonblock);
}

// Capture raw PCM data
void AlsaCore::capturev_go(int* fds, unsigned int channels,
		off64_t count, int rtype, char **names)
{
	size_t c;
	ssize_t r;
	unsigned int channel;
	size_t vsize;
	unsigned char *bufs[channels];

	header(rtype, names[0]);
	set_record_params();

	vsize = chunk_bytes / channels;

	for (channel = 0; channel < channels; ++channel) {
		bufs[channel] = audiobuf + vsize * channel;
	}

	while (count > 0 && !in_aborting) {
		size_t rv;
		c = count;
		if (c > chunk_bytes) {
			c = chunk_bytes;
		}
		c = c * 8 / bits_per_frame;

		if ((size_t)(r = pcm_readv(bufs, channels, c)) != c) {
			break;
		}
		rv = r * bits_per_sample / 8;

		for (channel = 0; channel < channels; ++channel) {
			if ((size_t)write(fds[channel], bufs[channel], rv) != rv) {
				perror(names[channel]);
				prg_exit(EXIT_FAILURE);
			}
		}

		r = r * bits_per_frame / 8;
		count -= r;
		fdcount += r;
	}
}

// Playback data
void AlsaCore::playbackv(char **names, unsigned int count)
{
	int ret = 0;
	unsigned int channel;
	unsigned int channels = rhwparams.channels;
	int alloced = 0;
	int fds[channels];

	// Initialize all channels
	for (channel = 0; channel < channels; ++channel) {
		fds[channel] = -1;
	}

	if (count == 1 && channels > 1) {
		size_t len = strlen(names[0]);
		char format[1024];
		memcpy(format, names[0], len);
		strcpy(format + len, ".%d");
		len += 4;
		names = (char **)malloc(sizeof(*names) * channels);
		for (channel = 0; channel < channels; ++channel) {
			names[channel] = (char *)malloc(len);
			sprintf(names[channel], format, channel);
		}
		alloced = 1;
	} else if (count != channels) {
		error(_("You need to specify %d files"), channels);
		prg_exit(EXIT_FAILURE);
	}

	// Check for channels unchanged
	for (channel = 0; channel < channels; ++channel) {
		fds[channel] = open(names[channel], O_RDONLY, 0);
		if (fds[channel] < 0) {
			perror(names[channel]);
			ret = EXIT_FAILURE;
			goto __end;
		}
	}

	// Should be raw data
	init_raw_data();
	pbrec_count = calc_count();
	playbackv_go(fds, channels, 0, pbrec_count, FORMAT_RAW, names);

	__end:
	for (channel = 0; channel < channels; ++channel) {
		if (fds[channel] >= 0) {
			close(fds[channel]);
		}
		if (alloced) {
			free(names[channel]);
		}
	}

	if (alloced) {
		free(names);
	}

	if (ret) {
		prg_exit(ret);
	}
}

// Capture raw data
void AlsaCore::capturev(char **names, unsigned int count)
{
	int ret = 0;
	unsigned int channel;
	unsigned int channels = rhwparams.channels;
	int alloced = 0;
	int fds[channels];

	// Initialize all channels
	for (channel = 0; channel < channels; ++channel) {
		fds[channel] = -1;
	}

	if (count == 1) {
		size_t len = strlen(names[0]);
		char format[1024];
		memcpy(format, names[0], len);
		strcpy(format + len, ".%d");
		len += 4;
		names = (char **)malloc(sizeof(*names) * channels);
		for (channel = 0; channel < channels; ++channel) {
			names[channel] = (char *)malloc(len);
			sprintf(names[channel], format, channel);
		}
		alloced = 1;
	} else if (count != channels) {
		error(_("You need to specify %d files"), channels);
		prg_exit(EXIT_FAILURE);
	}

	for (channel = 0; channel < channels; ++channel) {
		fds[channel] = open(names[channel], O_WRONLY + O_CREAT, 0644);
		if (fds[channel] < 0) {
			perror(names[channel]);
			ret = EXIT_FAILURE;
			goto __end;
		}
	}

	// Should be raw data
	init_raw_data();
	pbrec_count = calc_count();
	capturev_go(fds, channels, pbrec_count, FORMAT_RAW, names);

	__end:
	for (channel = 0; channel < channels; ++channel) {
		if (fds[channel] >= 0) {
			close(fds[channel]);
		}

		if (alloced) {
			free(names[channel]);
		}
	}

	if (alloced) {
		free(names);
	}

	if (ret) {
		prg_exit(ret);
	}
}

// Stop recording
void AlsaCore::stop_capture(void)
{
	capture_stop = 1;
}

// Set Play parameters
void AlsaCore::set_play_params(void)
{
	snd_pcm_hw_params_t *params;
	snd_pcm_sw_params_t *swparams;
	snd_pcm_uframes_t buffer_size;
	int err;
	size_t n;
	unsigned int rate;
	snd_pcm_uframes_t start_threshold, stop_threshold;

	snd_pcm_hw_params_alloca(&params);
	snd_pcm_sw_params_alloca(&swparams);

	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0) {
		error(_("Broken configuration for this PCM: no configurations available"));
		exit(EXIT_FAILURE);
	} else if (interleaved) {
		err = snd_pcm_hw_params_set_access(handle, params,
				SND_PCM_ACCESS_RW_INTERLEAVED);
	} else {
		err = snd_pcm_hw_params_set_access(handle, params,
				SND_PCM_ACCESS_RW_NONINTERLEAVED);
	}

	if (err < 0) {
		error(_("Access type not available"));
		exit(EXIT_FAILURE);
	}

	err = snd_pcm_hw_params_set_format(handle, params, hwparams.format);
	if (err < 0) {
		error(_("Sample format non available"));
		exit(EXIT_FAILURE);
	}

	err = snd_pcm_hw_params_set_channels(handle, params, hwparams.channels);
	if (err < 0) {
		error(_("Channels count non available"));
		exit(EXIT_FAILURE);
	}

#if 0
	err = snd_pcm_hw_params_set_periods_min(handle, params, 2);
	assert(err >= 0);
#endif

	rate = hwparams.rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &hwparams.rate, 0);
	assert(err >= 0);

	if ((float)rate * 1.05 < hwparams.rate || (float)rate * 0.95 > hwparams.rate) {
		if (!quiet_mode) {
			char plugex[64];
			const char *pcmname = snd_pcm_name(handle);

			fprintf(stderr, _("Warning: rate is not accurate (requested = %iHz, got = %iHz)\n"), rate, hwparams.rate);
			if (! pcmname || strchr(snd_pcm_name(handle), ':')) {
				*plugex = 0;
			} else {
				snprintf(plugex, sizeof(plugex), "(-Dplug:%s)",
						snd_pcm_name(handle));
			}

			fprintf(stderr, _(" please, try the plug plugin %s\n"),
					plugex);
		}
	}

	rate = hwparams.rate;
	if (buffer_time == 0 && buffer_frames == 0) {
		err = snd_pcm_hw_params_get_buffer_time_max(params,
				&buffer_time, 0);
		assert(err >= 0);
		if (buffer_time > 500000)
			buffer_time = 500000;
	}

	if (period_time == 0 && period_frames == 0) {
		if (buffer_time > 0) {
			period_time = buffer_time / 4;
		} else {
			period_frames = buffer_frames / 4;
		}
	}

	if (period_time > 0) {
		err = snd_pcm_hw_params_set_period_time_near(handle, params,
				&period_time, 0);
	} else {
		err = snd_pcm_hw_params_set_period_size_near(handle, params,
				&period_frames, 0);
	}
	assert(err >= 0);

	if (buffer_time > 0) {
		err = snd_pcm_hw_params_set_buffer_time_near(handle, params,
				&buffer_time, 0);
	} else {
		err = snd_pcm_hw_params_set_buffer_size_near(handle, params,
				&buffer_frames);
	}
	assert(err >= 0);

	err = snd_pcm_hw_params(handle, params);
	if (err < 0) {
		error(_("Unable to install hw params:"));
		snd_pcm_hw_params_dump(params, loghandle);
		exit(EXIT_FAILURE);
	}

	snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);
	snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
	if (chunk_size == buffer_size) {
		error(_("Can't use period equal to buffer size (%lu == %lu)"),
				chunk_size, buffer_size);
		exit(EXIT_FAILURE);
	}

	snd_pcm_sw_params_current(handle, swparams);
	if (avail_min < 0) {
		n = chunk_size;
	} else {
		n = (double) rate * avail_min / 1000000;
	}
	err = snd_pcm_sw_params_set_avail_min(handle, swparams, n);

	// Round up to closest transfer boundary
	n = buffer_size;
	if (start_delay <= 0) {
		start_threshold = n + (double) rate * start_delay / 1000000;
	} else {
		start_threshold = (double) rate * start_delay / 1000000;
	}

	if (start_threshold < 1) {
		start_threshold = 1;
	}
	if (start_threshold > n) {
		start_threshold = n;
	}

	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, start_threshold);
	assert(err >= 0);
	if (stop_delay <= 0) {
		stop_threshold = buffer_size + (double) rate * stop_delay / 1000000;
	} else {
		stop_threshold = (double) rate * stop_delay / 1000000;
	}

	err = snd_pcm_sw_params_set_stop_threshold(handle, swparams, stop_threshold);
	assert(err >= 0);

	if (snd_pcm_sw_params(handle, swparams) < 0) {
		error(_("unable to install sw params:"));
		snd_pcm_sw_params_dump(swparams, loghandle);
		exit(EXIT_FAILURE);
	}

	if (verbose) {
		snd_pcm_dump(handle, loghandle);
	}

	bits_per_sample = snd_pcm_format_physical_width(hwparams.format);
	bits_per_frame = bits_per_sample * hwparams.channels;
	chunk_bytes = chunk_size * bits_per_frame / 8;
	audiobuf = (unsigned char *)realloc(audiobuf, chunk_bytes);
	if (audiobuf == NULL) {
		error(_("not enough memory"));
		exit(EXIT_FAILURE);
	}

	// 	fprintf(stderr, "real chunk_size = %i, frags = %i, total = %i\n", chunk_size, setup.buf.block.frags, setup.buf.block.frags * chunk_size);

	// stereo VU-meter isn't always available...
	if (vumeter == VUMETER_STEREO) {
		if (hwparams.channels != 2 || !interleaved || verbose > 2)
			vumeter = VUMETER_MONO;
	}

	buffer_frames = buffer_size;	// For position test
}

// I/O error handler
void AlsaCore::xrun_record(void)
{
	snd_pcm_status_t *status;
	int res;

	snd_pcm_status_alloca(&status);
	if ((res = snd_pcm_status(handle, status)) < 0) {
		error(_("status error: %s"), snd_strerror(res));
		exit(EXIT_FAILURE);
	}

	if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
		struct timeval now, diff, tstamp;
		gettimeofday(&now, 0);
		snd_pcm_status_get_trigger_tstamp(status, &tstamp);
		timersub(&now, &tstamp, &diff);
		fprintf(stderr, _("%s!!! (at least %.3f ms long)\n"),
				stream == SND_PCM_STREAM_PLAYBACK ? _("underrun") : _("overrun"),
						diff.tv_sec * 1000 + diff.tv_usec / 1000.0);
		if (verbose) {
			fprintf(stderr, _("Status:\n"));
			snd_pcm_status_dump(status, loghandle);
		}

		if ((res = snd_pcm_prepare(handle)) < 0) {
			error(_("xrun: prepare error: %s"), snd_strerror(res));
			exit(EXIT_FAILURE);
		}

		return;	// ok, data should be accepted again
	}

	if (snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING) {
		if (verbose) {
			fprintf(stderr, _("Status(DRAINING):\n"));
			snd_pcm_status_dump(status, loghandle);
		}

		if (stream == SND_PCM_STREAM_CAPTURE) {
			fprintf(stderr, _("capture stream format change? attempting recover...\n"));
			if ((res = snd_pcm_prepare(handle)) < 0) {
				error(_("xrun(DRAINING): prepare error: %s"), snd_strerror(res));
				exit(EXIT_FAILURE);
			}
			return;
		}
	}

	if (verbose)
	{
		fprintf(stderr, _("Status(R/W):\n"));
		snd_pcm_status_dump(status, loghandle);
	}

	error(_("read/write error, state = %s"), snd_pcm_state_name(snd_pcm_status_get_state(status)));
	exit(EXIT_FAILURE);
}

// I/O suspend handler
void AlsaCore::suspend(void)
{
	int res;

	if (!quiet_mode) {
		fprintf(stderr, _("Suspended. Trying resume. ")); fflush(stderr);
	}

	while ((res = snd_pcm_resume(handle)) == -EAGAIN) {
		sleep(1);	// Wait until suspend flag is released
	}

	if (res < 0) {
		if (!quiet_mode) {
			fprintf(stderr, _("Failed. Restarting stream. ")); fflush(stderr);
		}

		if ((res = snd_pcm_prepare(handle)) < 0) {
			error(_("suspend: prepare error: %s"), snd_strerror(res));
			exit(EXIT_FAILURE);
		}
	}

	if (!quiet_mode) {
		fprintf(stderr, _("Done.\n"));
	}
}

// Calculate the PCM buffer data size to use
off64_t AlsaCore::calc_count(void)
{
	off64_t count;

	if (timelimit == 0) {
		count = pbrec_count;
	} else {
		count = snd_pcm_format_size(hwparams.format, hwparams.rate * hwparams.channels);
		count *= (off64_t)timelimit;
	}

	return count < pbrec_count ? count : pbrec_count;
}

// Create a new file to record to
int AlsaCore::new_capture_file(char *name, char *namebuf,
		size_t namelen, int filecount)
{
	// Get a copy of the original filename
	char *s;
	char buf[PATH_MAX+1];

	strncpy(buf, name, sizeof(buf));

	// Separate extension from filename
	s = buf + strlen(buf);
	while (s > buf && *s != '.' && *s != '/')
		--s;
	if (*s == '.') {
		*s++ = 0;
	}else if (*s == '/') {
		s = buf + strlen(buf);
	}

	// Upon first jump to this if block rename the first file
	if (filecount == 1) {
		if (*s) {
			snprintf(namebuf, namelen, "%s-01.%s", buf, s);
		} else {
			snprintf(namebuf, namelen, "%s-01", buf);
		}
		remove(namebuf);
		rename(name, namebuf);
		filecount = 2;
	}

	// Name of the current file
	if (*s) {
		snprintf(namebuf, namelen, "%s-%02i.%s", buf, filecount, s);
	} else {
		snprintf(namebuf, namelen, "%s-%02i", buf, filecount);
	}

	return filecount;
}


// Set Stream Parameters
int AlsaCore::setparams_stream(snd_pcm_t *handle,
		snd_pcm_hw_params_t *params,
		const char *id)
{
	int err;
	unsigned int rrate;
	int dir = 0;

	// Get HW parameter if any
	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0) {
		printf("Broken configuration for %s PCM: no configurations available: %s\n", snd_strerror(err), id);
		return err;
	}

	// Set resample rate
	err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
	if (err < 0) {
		printf("Resample setup failed for %s (val %i): %s\n", id, resample, snd_strerror(err));
		return err;
	}

	// Set HW access
	err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
	if (err < 0) {
		printf("Access type not available for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// Set HW format
	err = snd_pcm_hw_params_set_format(handle, params, hwparams.format);
	if (err < 0) {
		printf("Sample format not available for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// Set number of channels
	err = snd_pcm_hw_params_set_channels(handle, params, hwparams.channels);
	if (err < 0) {
		printf("Channels count (%i) not available for %s: %s\n",  hwparams.channels, id, snd_strerror(err));
		return err;
	}

	// Set the rate
	rrate = hwparams.rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, &dir);
	if (err < 0) {
		printf("Rate %iHz not available for %s: %s\n",  hwparams.rate, id, snd_strerror(err));
		return err;
	}

	// Check the rate
	if (rrate != hwparams.rate) {
		printf("Rate doesn't match (requested %iHz, get %iHz)\n", hwparams.rate, err);
		return -EINVAL;
	}

	return (0);
}

// Set buffer size
int AlsaCore::setparams_bufsize(snd_pcm_t *handle,
		snd_pcm_hw_params_t *params,
		snd_pcm_hw_params_t *tparams,
		snd_pcm_uframes_t bufsize,
		const char *id)
{
	int err;
	snd_pcm_uframes_t periodsize;

	snd_pcm_hw_params_copy(params, tparams);
	periodsize = bufsize * 2;
	printf(" spbf: in bufsize:%li; periodsize %li for %s\n", bufsize, periodsize, id); //added

	err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &periodsize);
	if (err < 0) {
		printf("Unable to set buffer size %li for %s: %s\n", bufsize * 2, id, snd_strerror(err));
		return err;
	}
	printf("     : set_buffer_size_near: %li for %s\n", periodsize, id);                //added

	if (period_size > 0) {
		periodsize = period_size;
	} else {
		periodsize /= 2;
	}
	printf("     : now periodsize %li for %s\n", periodsize, id);                       //added

	err = snd_pcm_hw_params_set_period_size_near(handle, params, &periodsize, 0);
	if (err < 0) {
		printf("Unable to set period size %li for %s: %s\n", periodsize, id, snd_strerror(err));
		return err;
	}
	printf("     : set_period_size_near: %li for %s\n", periodsize, id);                //added

	return (0);
}

// Set parameters set
int AlsaCore::setparams_set(snd_pcm_t *handle,
		snd_pcm_hw_params_t *params,
		snd_pcm_sw_params_t *swparams,
		const char *id)
{
	int err;
	snd_pcm_uframes_t val;

	// Set the HW parameters
	err = snd_pcm_hw_params(handle, params);
	if (err < 0) {
		printf("Unable to set hw params for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// Set the current parameters
	err = snd_pcm_sw_params_current(handle, swparams);
	if (err < 0) {
		printf("Unable to determine current swparams for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// Set the starting threshold
	err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0x7fffffff);
	if (err < 0) {
		printf("Unable to set start threshold mode for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// If not blocking, then get the period size
	if (!block) {
		val = 4;
	} else {
		snd_pcm_hw_params_get_period_size(params, &val, NULL);
	}

	// Set the available minimum
	err = snd_pcm_sw_params_set_avail_min(handle, swparams, val);
	if (err < 0) {
		printf("Unable to set avail min for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	// Set the SW parameters
	err = snd_pcm_sw_params(handle, swparams);
	if (err < 0) {
		printf("Unable to set sw params for %s: %s\n", id, snd_strerror(err));
		return err;
	}

	return (0);
}

// Setup stream parameters
int AlsaCore::set_stream_params(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
{
	int err, last_bufsize = *bufsize;
	snd_pcm_hw_params_t *pt_params, *ct_params; // templates with rate, format and channels
	snd_pcm_hw_params_t *p_params, *c_params;
	snd_pcm_sw_params_t *p_swparams, *c_swparams;
	snd_pcm_uframes_t p_size, c_size, p_psize, c_psize;
	unsigned int p_time, c_time;
	unsigned int val;

	// Allocate memory for parameters
	snd_pcm_hw_params_alloca(&p_params);
	snd_pcm_hw_params_alloca(&c_params);
	snd_pcm_hw_params_alloca(&pt_params);
	snd_pcm_hw_params_alloca(&ct_params);
	snd_pcm_sw_params_alloca(&p_swparams);
	snd_pcm_sw_params_alloca(&c_swparams);

	if ((err = setparams_stream(phandle, pt_params, "playback")) < 0) {
		printf("Unable to set parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	if ((err = setparams_stream(chandle, ct_params, "capture")) < 0) {
		printf("Unable to set parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	if (buffer_size > 0) {
		*bufsize = buffer_size;
		goto __set_it;
	}

	__again:
	if (buffer_size > 0) {
		return (-1);
	}

	if (last_bufsize == *bufsize) {
		*bufsize += 4;
	}

	last_bufsize = *bufsize;
	if (*bufsize > latency_max) {
		return (-1);
	}

	__set_it:
	if ((err = setparams_bufsize(phandle, p_params, pt_params, *bufsize, "playback")) < 0) {
		printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	if ((err = setparams_bufsize(chandle, c_params, ct_params, *bufsize, "capture")) < 0) {
		printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	snd_pcm_hw_params_get_period_size(p_params, &p_psize, NULL);
	if (p_psize > (unsigned int)*bufsize) {
		*bufsize = p_psize;
	}

	snd_pcm_hw_params_get_period_size(c_params, &c_psize, NULL);
	if (c_psize > (unsigned int)*bufsize) {
		*bufsize = c_psize;
	}

	snd_pcm_hw_params_get_period_time(p_params, &p_time, NULL);
	snd_pcm_hw_params_get_period_time(c_params, &c_time, NULL);
	if (p_time != c_time) {
		goto __again;
	}

	snd_pcm_hw_params_get_buffer_size(p_params, &p_size);
	if (p_psize * 2 < p_size) {
		snd_pcm_hw_params_get_periods_min(p_params, &val, NULL);
		if (val > 2) {
			printf("playback device does not support 2 periods per buffer\n");
			exit(0);
		}
		goto __again;
	}

	snd_pcm_hw_params_get_buffer_size(c_params, &c_size);
	if (c_psize * 2 < c_size) {
		snd_pcm_hw_params_get_periods_min(c_params, &val, NULL);
		if (val > 2 ) {
			printf("capture device does not support 2 periods per buffer\n");
			exit(0);
		}
		goto __again;
	}

	if ((err = setparams_set(phandle, p_params, p_swparams, "playback")) < 0) {
		printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	if ((err = setparams_set(chandle, c_params, c_swparams, "capture")) < 0) {
		printf("Unable to set sw parameters for playback stream: %s\n", snd_strerror(err));
		exit(0);
	}

	if ((err = snd_pcm_prepare(phandle)) < 0) {
		printf("Prepare error: %s\n", snd_strerror(err));
		exit(0);
	}

	snd_pcm_dump(phandle, output);
	snd_pcm_dump(chandle, output);
	fflush(stdout);

	return (0);
}

// Show statistics
void AlsaCore::showstat(snd_pcm_t *handle, size_t frames)
{
	int err;
	snd_pcm_status_t *status;
	snd_pcm_status_alloca(&status);

	// Print pcm status
	if ((err = snd_pcm_status(handle, status)) < 0) {
		printf("Stream status error: %s\n", snd_strerror(err));
		exit(0);
	}
#if 0
	printf("*** frames = %li ***\n", (long)frames);

	// Display status
	snd_pcm_status_dump(status, output);
#endif
}

// Show latency
void AlsaCore::showlatency(size_t latency)
{
	latency *= 2;

#ifdef _DEBUG
	double d;
	d = (double)latency / (double)hwparams.rate;
	printf("Trying latency %li frames, %.3fus, %.6fms (%.4fHz)\n", (long)latency, d * 1000000, d * 1000, (double)1 / d);
#endif
}

// Show in max
void AlsaCore::showinmax(size_t in_max)
{
	printf("Maximum read: %li frames\n", (long)in_max);

#ifdef _DEBUG
	double d;
	d = (double)in_max / (double)hwparams.rate;
	printf("Maximum read latency: %.3fus, %.6fms (%.4fHz)\n", d * 1000000, d * 1000, (double)1 / d);
#endif
}

// Get the time stamp
void AlsaCore::gettimestamp(snd_pcm_t *handle, snd_timestamp_t *timestamp)
{
	int err;
	snd_pcm_status_t *status;
	snd_pcm_status_alloca(&status);
	if ((err = snd_pcm_status(handle, status)) < 0) {
		printf("Stream status error: %s\n", snd_strerror(err));
		exit(0);
	}
	snd_pcm_status_get_trigger_tstamp(status, timestamp);
}

// Set the scheduler
void AlsaCore::setscheduler(void)
{
	struct sched_param sched_param;
	if (sched_getparam(0, &sched_param) < 0) {
		printf("Scheduler getparam failed...\n");
		return;
	}

	// Get the maximum scheduled priority
	sched_param.sched_priority = sched_get_priority_max(SCHED_RR);
	if (!sched_setscheduler(0, SCHED_RR, &sched_param)) {
		printf("Scheduler set to Round Robin with priority %i...\n", sched_param.sched_priority);
		fflush(stdout);
	} else {
		// Display scheduled priority
		printf("!!!Scheduler set to Round Robin with priority %i FAILED!!!\n", sched_param.sched_priority);
	}
}

// Determine time stamp difference
long AlsaCore::timediff(snd_timestamp_t t1, snd_timestamp_t t2)
{
	signed long l;
	t1.tv_sec -= t2.tv_sec;
	l = (signed long) t1.tv_usec - (signed long) t2.tv_usec;

	if (l < 0) {
		t1.tv_sec--;
		l = 1000000 + l;
		l %= 1000000;
	}

	return (t1.tv_sec * 1000000) + l;
}

// Write the PCM buffer
long AlsaCore::writebuf(snd_pcm_t *handle, char *buf, long len, size_t *frames)
{
	long r;
	while (len > 0)
	{
		r = snd_pcm_writei(handle, buf, len);
		if (r == -EAGAIN) {
			continue;
		}
		printf("write = %li\n", r);

		if (r < 0) {
			return r;
		}

		buf += r * 4;
		len -= r;
		*frames += r;
	}

	showstat(handle, *frames);

	return (0);
}

// Read the PCM buffer
long AlsaCore::readbuf(snd_pcm_t *handle, char *buf, long len, size_t *frames, size_t *max)
{
	long r;
	if (!block) {
		do {
			r = snd_pcm_readi(handle, buf, len);
		}
		while (r == -EAGAIN);

		if (r > 0) {
			*frames += r;
			if ((long)*max < r) {
				*max = r;
			}
		}
		printf("read = %li\n", r);
	} else {
		int frame_bytes = (snd_pcm_format_width(hwparams.format) / 8) * hwparams.channels;
		do {
			r = snd_pcm_readi(handle, buf, len);
			if (r > 0) {
				buf += r * frame_bytes;
				len -= r;
				*frames += r;
				if ((long)*max < r)
					*max = r;
			}
			printf("read = %li, len = %li\n", r, len);
		}
		while (r >= 1 && len > 0);
	}

	showstat(handle, *frames);

	return r;
}

// Apply effect
void AlsaCore::applyeffect(char* buffer, int r)
{
	short* samples = (short*) buffer;
	int i;

	for (i = 0; i < r; i++) {
		int chn;
		fc = sin(lfo) * FILTERSWEEP_LFO_DEPTH + FILTERSWEEP_LFO_CENTER;
		lfo += dlfo;
		if (lfo  > 2. * M_PI) {
			lfo -= 2. * M_PI;
		}
		C = 1. / tan(M_PI * BW / fs);
		D = 2. * cos(2 * M_PI * fc / fs);
		a0 = 1. / (1. + C);
		a1 = 0;
		a2 = -a0;
		b1 = -C * D * a0;
		b2 = (C - 1) * a0;
		for (chn = 0; chn < (int)hwparams.channels; chn++) {
			x[chn][2] = x[chn][1];
			x[chn][1] = x[chn][0];
			y[chn][2] = y[chn][1];
			y[chn][1] = y[chn][0];
			x[chn][0] = samples[i * hwparams.channels + chn];
			y[chn][0] = a0 * x[chn][0] + a1 * x[chn][1] + a2 * x[chn][2] - b1 * y[chn][1] - b2 * y[chn][2];
			samples[i * hwparams.channels + chn] = y[chn][0];
		}
	}
}

